Inizia code assisted review (non compila...)

2026-06-02 15:44:25 +02:00
parent 537ebec330
commit 712bc5e380
13 changed files with 1518 additions and 13 deletions
@@ -0,0 +1,176 @@
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.Configuration;
+using MP.Core.DTO;
+using MP.Core.Objects;
+using MP.Data.DbModels;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace MP.Data.Repository.FluxLog
+{
+    public class FluxLogRepository : IFluxLogRepository
+    {
+        #region Private Fields
+
+        private readonly IConfiguration _configuration;
+        private static NLog.Logger Log = NLog.LogManager.GetCurrentClassLogger();
+
+        #endregion
+
+        #region Public Constructors
+
+        public FluxLogRepository(IConfiguration configuration)
+        {
+            _configuration = configuration;
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <inheritdoc />
+        public async Task<List<StatDedupDTO>> FluxLogDataReduxAsync(string idxMaccSel, List<string> fluxList, Periodo currPeriodo, Enums.ValSelection valMode, Enums.DataInterval intReq, int maxItem)
+        {
+            List<StatDedupDTO> procStats = new List<StatDedupDTO>();
+            Log.Info($"Inizio FluxLogDataReduxAsync | idxMaccSel: {idxMaccSel} | periodo: {currPeriodo.Inizio:yyyy-MM-dd} --> {currPeriodo.Fine:yyyy-MM-dd}");
+            TimeSpan step = TimeSpan.FromHours(1);
+            switch (intReq)
+            {
+                case Enums.DataInterval.minute:
+                    step = TimeSpan.FromMinutes(1.00 / maxItem);
+                    break;
+
+                case Enums.DataInterval.hour:
+                    step = TimeSpan.FromHours(1.00 / maxItem);
+                    break;
+
+                case Enums.DataInterval.day:
+                    step = TimeSpan.FromDays(1.00 / maxItem);
+                    break;
+
+                default:
+                    break;
+            }
+
+            var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMaccSel);
+            var pOnlyTest = new SqlParameter("@OnlyTest", false);
+
+            await using var dbCtx = new MoonPro_FluxContext(_configuration);
+            foreach (var item in fluxList)
+            {
+                Log.Info($"FluxLogDataReduxAsync | Flux: {item}");
+                int numRecProc = 0;
+                Stopwatch sw = new Stopwatch();
+                sw.Start();
+                var pCodFlux = new SqlParameter("@CodFlux", item);
+                DateTime dtCursStart = currPeriodo.Inizio;
+                DateTime dtCursEnd = dtCursStart.Add(step);
+                bool setCompleted = false;
+                while (!setCompleted)
+                {
+                    var currFlux = await dbCtx
+                             .DbSetFluxLog
+                             .Where(x => (x.CodFlux == item) && (x.dtEvento >= dtCursStart && x.dtEvento < dtCursEnd) && (x.IdxMacchina == idxMaccSel))
+                             .ToListAsync();
+
+                    int numRec = currFlux.Count;
+                    numRecProc += numRec;
+                    if (numRec > maxItem)
+                    {
+                        List<Periodo> listPeriodi = new List<Periodo>();
+
+                        switch (valMode)
+                        {
+                            case Enums.ValSelection.First:
+                                var recStart = currFlux.Skip(1).FirstOrDefault();
+                                listPeriodi.Add(new Periodo(recStart.dtEvento, dtCursEnd));
+                                break;
+
+                            case Enums.ValSelection.Last:
+                                var recEnd = currFlux.LastOrDefault();
+                                listPeriodi.Add(new Periodo(dtCursStart, recEnd.dtEvento));
+                                break;
+
+                            case Enums.ValSelection.Center:
+                                int idx = 1;
+                                var recCent = currFlux.Skip(idx / (maxItem + 1)).FirstOrDefault();
+                                listPeriodi.Add(new Periodo(dtCursStart, recCent.dtEvento));
+                                if (maxItem > 1)
+                                {
+                                    for (int i = 2; i < maxItem; i++)
+                                    {
+                                        DateTime dtInizio = recCent.dtEvento;
+                                        recCent = currFlux.Skip(i / (maxItem + 1)).FirstOrDefault();
+                                        listPeriodi.Add(new Periodo(dtInizio, recCent.dtEvento));
+                                    }
+                                }
+                                listPeriodi.Add(new Periodo(recCent.dtEvento.AddSeconds(1), dtCursEnd));
+                                break;
+
+                            default:
+                                break;
+                        }
+
+                        foreach (var slot in listPeriodi)
+                        {
+                            var pDtStart = new SqlParameter("@DtStart", slot.Inizio);
+                            var pDtEnd = new SqlParameter("@DtEnd", slot.Fine);
+                            await dbCtx
+                                            .Database
+                                            .ExecuteSqlRawAsync("EXEC man.stp_ReduceFluxLog @IdxMacchina, @CodFlux, @DtStart, @DtEnd, @OnlyTest", pIdxMacchina, pCodFlux, pDtStart, pDtEnd, pOnlyTest);
+                        }
+                    }
+
+                    dtCursStart = dtCursEnd;
+                    dtCursEnd = dtCursStart.Add(step);
+                    setCompleted = dtCursStart >= currPeriodo.Fine;
+                }
+                sw.Stop();
+                StatDedupDTO currStat = new StatDedupDTO()
+                {
+                    IdxMacchina = idxMaccSel,
+                    CodFlux = item,
+                    Interval = intReq,
+                    Num4Int = maxItem,
+                    NumRec = numRecProc,
+                    ProcTime = sw.Elapsed.TotalSeconds
+                };
+                procStats.Add(currStat);
+            }
+            Log.Info($"FINE FluxLogDataReduxAsync | idxMaccSel: {idxMaccSel} | periodo: {currPeriodo.Inizio:yyyy-MM-dd} --> {currPeriodo.Fine:yyyy-MM-dd}");
+            return procStats;
+        }
+
+        /// <inheritdoc />
+        public async Task<List<FluxLogModel>> FluxLogGetLastFiltAsync(DateTime DtMax, DateTime DtMin, string IdxMacchina, string CodFlux, int MaxRec)
+        {
+            await using var dbCtx = new MoonPro_FluxContext(_configuration);
+            return await dbCtx
+                        .DbSetFluxLog
+                        .AsNoTracking()
+                        .Where(x => (x.dtEvento >= DtMin && x.dtEvento <= DtMax) && (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina) && (CodFlux == "*" || x.CodFlux == CodFlux))
+                        .OrderByDescending(x => x.dtEvento)
+                        .Take(MaxRec)
+                        .ToListAsync() ?? new();
+        }
+
+        /// <inheritdoc />
+        public async Task<List<ParetoFluxLogDTO>> FluxLogParetoAsync(string idxMacchina, DateTime dtFrom, DateTime dtTo)
+        {
+            await using var dbCtx = new MoonPro_FluxContext(_configuration);
+            return await dbCtx
+                        .DbSetFluxLog
+                        .Where(x => (string.IsNullOrEmpty(idxMacchina) || x.IdxMacchina == idxMacchina) && (dtFrom <= x.dtEvento && x.dtEvento <= dtTo))
+                        .AsNoTracking()
+                        .GroupBy(x => x.CodFlux)
+                        .Select(g => new ParetoFluxLogDTO() { IdxMacchina = idxMacchina, CodFlux = g.Key, Qty = g.Count() })
+                        .OrderByDescending(x => x.Qty)
+                        .ToListAsync() ?? new();
+        }
+
+        #endregion
+    }
+}