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

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

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

        protected static Logger Log = LogManager.GetCurrentClassLogger();
        protected SelectSMIn2EvParams currFilter = new SelectSMIn2EvParams();
        protected Dictionary<int, string> eventsFromDb = new Dictionary<int, string>();
        protected DataPager? pagerRulFix = null!;
        protected Dictionary<int, string> statesFromDb = new Dictionary<int, string>();

        #endregion Protected Fields

        #region Protected Properties

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

        protected int maxAllowedFiles { get; set; } = 100;

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

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

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

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

        #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()
        {
            // path cartella root (development)
            pathDir = Path.Combine("Temp", "unsafe_uploads");
            // se la cartella non esistesse la creo
            if (!Directory.Exists(pathDir))
            {
                Directory.CreateDirectory(pathDir);
                Log.Info($"Creato directory {pathDir}");
            }

            // svuoto cartella prima di partire
            deleteOldFiles(pathDir);
            await Task.Delay(1);
            await SMGDService.ExecFlushRedisPattern(Core.Constants.FILES_TO_PROC);
        }

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

        protected async Task ReloadData()
        {
            Files = await SMGDService.FilesGetAll();
        }

        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(-10))
                {
                    fi.Delete();
                }
            }
        }

        private async Task LoadFiles(InputFileChangeEventArgs e)
        {
            List<IBrowserFile> loadedFiles = new();
            long maxFileSize = 1024 * 1024;
            loadedFiles.Clear();
            Files.Clear();

            // svuoto cartella prima di partire
            deleteOldFiles(pathDir);

            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(pathDir, trustedFileNameForFileStorage);

                    // creo file
                    using (FileStream fs = new(pathFile, FileMode.Create))
                    {
                        // copio il contenuto del file
                        await file.OpenReadStream(maxFileSize).CopyToAsync(fs);
                        // scrivo log
                        Log.Info($"Salvato file temp {pathFile}");
                    }

                    if (file.Name.Contains(".rul"))
                    {
                        var newFIle = new FilesClass()
                        {
                            tempFileName = pathFile,
                            isOk = false,
                            origFileName = file.Name,
                            calcRunning = false,
                            DLoadFileName = ""
                        };

                        Files.Add(file.Name, newFIle);
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore durante salvataggio file temp {file.Name}: {exc}{Environment.NewLine}");
                }
            }
            if (Files != null && Files.Count > 0)
            {
                await SMGDService.FilesLoadRedis(Files);
            }
            resetSucc = 0;
            await InvokeAsync(() => StateHasChanged());
            await ReloadData();
        }

        #endregion Private Methods
    }
}