gwms/GWMS.Data/Controllers/GWMSController.cs

using GWMS.Data.DatabaseModels;
using GWMS.Data.DTO;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace GWMS.Data.Controllers
{
    public class GWMSController : IDisposable
    {
        #region Private Fields

        private static IConfiguration _configuration;
        private static GWMSContext dbCtx;
        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Public Constructors

        public GWMSController(IConfiguration configuration)
        {
            _configuration = configuration;
            dbCtx = new GWMSContext(configuration);
            //Log.Info("Avviata classe GWMSController");
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Calcola DataOra arrotondata per eccesso secondo intervallo minuti indicato
        /// </summary>
        /// <param name="dateOrig"></param>
        /// <param name="minInt"></param>
        /// <returns></returns>
        public DateTime DateRoundEnd(DateTime dateOrig, int minInt)
        {
            int minRound = (int)Math.Ceiling((double)dateOrig.Minute / minInt) * minInt;
            DateTime roundDate = dateOrig.Date.AddHours(dateOrig.Hour).AddMinutes(minRound);
            return roundDate;
        }

        public void Dispose()
        {
            // Clear database context
            dbCtx.Dispose();
            //Log.Info("Dispose di GWMSController");
        }

        public List<ConfigModel> GetConfig()
        {
            var dbResult = dbCtx
                .DbSetConfig
                .ToList();

            return dbResult;
        }

        public List<ItemModel> GetItems()
        {
            var dbResult = dbCtx
                .DbSetItems
                .ToList();

            return dbResult;
        }

        public OrderModel GetOrderByCode(string OrderCode)
        {
            OrderModel dbResult = new OrderModel();
            using (GWMSContext localDbCtx = new GWMSContext(_configuration))
            {
                dbResult = localDbCtx
                    .DbSetOrders
                    .Where(x => (x.OrderCode == OrderCode))
                    .Include(p => p.Plant)
                    .Include(s => s.Supplier)
                    .Include(t => t.Transporter)
                    .FirstOrDefault();
            }
            return dbResult;
        }

        public List<OrderModel> GetOrdersFilt(int PlantId, int SupplierId, int TransporterId, DateTime DtStart, DateTime DtEnd, bool ShowClosed)
        {
            var dbResult = dbCtx
                .DbSetOrders
                .Where(x => (x.PlantId == PlantId || PlantId == 0) && (x.SupplierId == SupplierId || SupplierId == 0) && (x.TransporterId == TransporterId || TransporterId == 0) && (x.DtOrder >= DtStart && x.DtOrder <= DtEnd) && (x.ExecutionQty == 0 || ShowClosed))
                .Include(p => p.Plant)
                .Include(s => s.Supplier)
                .Include(t => t.Transporter)
                .OrderByDescending(x => x.DtOrder)
                .ToList();

            return dbResult;
        }

        public List<OrderModel> GetOrdersOpen(int PlantId)
        {
            var dbResult = dbCtx
                .DbSetOrders
                .Where(x => (x.PlantId == PlantId || PlantId == 0) && (x.DtExecStart < x.DtOrder))
                .Include(p => p.Plant)
                .Include(s => s.Supplier)
                .Include(t => t.Transporter)
                .OrderByDescending(x => x.DtOrder)
                .ToList();

            return dbResult;
        }

        public PlantDetailModel GetPlant(int PlantId)
        {
            var dbResult = dbCtx
                .DbSetPlant
                .Where(x => x.PlantId == PlantId)
                .FirstOrDefault();

            return dbResult;
        }

        /// <summary>
        /// Elenco log registrati x plant
        /// </summary>
        /// <param name="PlantId">se 0 = tutto</param>
        /// <param name="DtMaxDate">consigliato arrotondamento al minuto o multiplo</param>
        /// <param name="numRec">num rec max da recuperare</param>
        /// <returns></returns>
        public List<PlantLogModel> GetPlantLog(int PlantId, DateTime DtMaxDate, int numRec)
        {
            var dbResult = dbCtx
                .DbSetPlantLog
                .Where(x => (x.PlantId == PlantId || PlantId == 0) && x.DtEvent <= DtMaxDate)
                .OrderByDescending(x => x.DtEvent)
                .Take(numRec)
                .ToList();

            return dbResult;
        }

        public List<PlantDetailModel> GetPlants()
        {
            var dbResult = dbCtx
                .DbSetPlant
                .ToList();

            return dbResult;
        }

        public List<PlantDTO> GetPlantsDTO(int maxRecords)
        {
            List<PlantDTO> dbResult = new List<PlantDTO>();
            using (GWMSContext localDbCtx = new GWMSContext(_configuration))
            {
                var plantList = localDbCtx
                    .DbSetPlant
                    .ToList();

                dbResult = plantList
                .Select(x => PlantDTO(x.PlantId, maxRecords))
                .ToList();
            }

            return dbResult;
        }

        /// <summary>
        /// Restituisce ultimi eventi rebootlog
        /// </summary>
        /// <param name="maxNum">num eventi, se 0 = tutti</param>
        /// <returns></returns>
        public List<RebootLogModel> GetRebootLog(int maxNum = 100)
        {
            if (maxNum == 0)
            {
                maxNum = dbCtx.DbRebootLog.Count();
            }
            var dbResult = dbCtx
                .DbRebootLog
                .OrderByDescending(x => x.DtEvent)
                .Take(maxNum)
                .ToList();

            return dbResult;
        }

        public List<SupplierModel> GetSuppliers()
        {
            var dbResult = dbCtx
                .DbSetSupplier
                .ToList();

            return dbResult;
        }

        public List<TransporterModel> GetTransporters()
        {
            var dbResult = dbCtx
                .DbSetTransporter
                .ToList();

            return dbResult;
        }

        public List<UserModel> GetUsersFilt(UserLevel UsrLvl, int PlantId, int SupplierId, int TransporterId)
        {
            var dbResult = dbCtx
                .DbSetUser
                .Where(x => (x.Livello == UsrLvl || UsrLvl == UserLevel.ND) && (x.MaskPlantId == PlantId || PlantId == 0) && (x.MaskSupplierId == SupplierId || SupplierId == 0) && (x.MaskTranspId == TransporterId || TransporterId == 0))
                .OrderBy(x => x.Livello)
                .ThenBy(x => x.UserName)
                .ToList();

            return dbResult;
        }

        public List<WeekPlanModel> GetWeekPlan()
        {
            List<WeekPlanModel> dbResult = new List<WeekPlanModel>();
            using (GWMSContext localDbCtx = new GWMSContext(_configuration))
            {
                dbResult = localDbCtx
                    .DbSetPlantSupplWeekPlan
                    .Include(p => p.Plant)
                    .Include(s => s.Supplier)
                    .Include(t => t.Transporter)
                    .ToList();
            }
            return dbResult;
        }

        public bool HasPlantLog()
        {
            bool answ = false;
            try
            {
                var numRecord = dbCtx
                    .DbSetPlantLog
                    .Count();
                answ = numRecord > 0;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Eliminazione di un ordine
        /// </summary>
        /// <param name="Item2Del"></param>
        /// <returns></returns>
        public bool OrderDelete(OrderModel Item2Del)
        {
            bool done = false;
            try
            {
                if (Item2Del != null)
                {
                    dbCtx
                        .DbSetOrders
                        .Remove(Item2Del);
                    dbCtx.SaveChanges();
                    done = true;
                }
            }
            catch (Exception exc)
            { }
            return done;
        }

        /// <summary>
        /// Aggiunta in blocco di Ordini
        /// </summary>
        /// <param name="newItems"></param>
        /// <returns></returns>
        public bool OrderInsert(List<OrderModel> newItems)
        {
            bool done = false;
            try
            {
                dbCtx
                    .DbSetOrders
                    .AddRange(newItems);
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            { }
            return done;
        }

        /// <summary>
        /// Aggiorna un Ordine
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool OrderUpdate(OrderModel updItem)
        {
            bool done = false;
            try
            {
                OrderModel currData = null;
                currData = dbCtx
                   .DbSetOrders
                   .Where(x => x.OrderId == updItem.OrderId)
                   .FirstOrDefault();
                if (currData != null)
                {
                    using (GWMSContext localDbCtx = new GWMSContext(_configuration))
                    {
                        // se ho modificato data --> cambio codice ordine!
                        if (!localDbCtx.Entry(updItem).OriginalValues["DtOrder"].Equals(localDbCtx.Entry(updItem).CurrentValues["DtOrder"]))
                        {
                            updItem.OrderCode = $"O{updItem.Plant.PlantCode}{updItem.DtOrder:yyMMddHHmm}";
                            updItem.OrderDesc = $"Ordine {updItem.Plant.PlantDesc} - {updItem.DtOrder}";
                        }
                        localDbCtx.Entry(updItem).State = EntityState.Modified;
                        localDbCtx.SaveChanges();
                    }
                }
                else
                {
                    dbCtx
                        .DbSetOrders
                        .Add(updItem);
                    dbCtx.SaveChanges();
                }
                done = true;
            }
            catch (Exception exc)
            { }
            return done;
        }

        /// <summary>
        /// Recupero info PLANT modalità DTO
        /// </summary>
        /// <param name="PlantId">Impianto</param>
        /// <param name="PlantId">Max numero di record da recuperare</param>
        /// <returns></returns>
        public PlantDTO PlantDTO(int PlantId, int maxRecords)
        {
            DateTime lastRec = DateTime.Today;
            var currPlant = GetPlant(PlantId);
            PlantDTO answ = new PlantDTO();
            List<TSData> LevelTS = new List<TSData>();
            Dictionary<string, double> PressAct = new Dictionary<string, double>();
            Dictionary<string, List<TSData>> PressTS = new Dictionary<string, List<TSData>>();
            List<TSData> PressMainTS = new List<TSData>();
            List<TSData> PressBHTS = new List<TSData>();
            List<TSData> PressBLTS = new List<TSData>();
            List<TSData> OrderTS = new List<TSData>();

            using (GWMSContext localDbCtx = new GWMSContext(_configuration))
            {
                // recupero dal DB
                var rawLevelData = localDbCtx
                                .DbSetPlantLog
                                .Where(x => x.FluxType == "Level" && x.PlantId == PlantId)
                                .OrderByDescending(x => x.DtEvent)
                                .Take(maxRecords)
                                .OrderBy(x => x.DtEvent)
                                .ToList();

                var rawMainPressData = localDbCtx
                                    .DbSetPlantLog
                                    .Where(x => x.FluxType == "MainPress" && x.PlantId == PlantId)
                                    .OrderByDescending(x => x.DtEvent)
                                    .Take(maxRecords)
                                    .OrderBy(x => x.DtEvent)
                                    .ToList();

                var rawBHPressData = localDbCtx
                                    .DbSetPlantLog
                                    .Where(x => x.FluxType == "PressBH" && x.PlantId == PlantId)
                                    .OrderByDescending(x => x.DtEvent)
                                    .Take(maxRecords)
                                    .OrderBy(x => x.DtEvent)
                                    .ToList();

                var rawBLPressData = localDbCtx
                                    .DbSetPlantLog
                                    .Where(x => x.FluxType == "PressBL" && x.PlantId == PlantId)
                                    .OrderByDescending(x => x.DtEvent)
                                    .Take(maxRecords)
                                    .OrderBy(x => x.DtEvent)
                                    .ToList();

                var rawOrderData = localDbCtx
                                    .DbSetOrders
                                    .Where(x => x.PlantId == PlantId && x.ExecutionQty == 0)
                                    .OrderByDescending(x => x.DtOrder)
                                    .Take(maxRecords)
                                    .OrderBy(x => x.DtOrder)
                                    .ToList();

                LevelTS = rawLevelData
                            .Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();

                OrderTS = rawOrderData
                            .Select(x => new TSData() { DtEvent = x.DtOrder, ValDouble = x.OrderQty }).ToList();

                PressMainTS = rawMainPressData
                            .Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();

                PressBHTS = rawBHPressData
                            .Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();

                PressBLTS = rawBLPressData
                            .Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();

                PressTS.Add("Main", PressMainTS);
                PressTS.Add("BH", PressBHTS);
                PressTS.Add("BL", PressBLTS);

                double actLevel = LevelTS.Count > 0 ? LevelTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble : 0;
                double valMain = PressMainTS.Count > 0 ? PressMainTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble : 0;
                double valBH = PressBHTS.Count > 0 ? PressBHTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble : 0;
                double valBL = PressBLTS.Count > 0 ? PressBLTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble : 0;

                lastRec = LevelTS.Count > 0 ? LevelTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().DtEvent : DateTime.Today;

                PressAct.Add("Main", valMain);
                PressAct.Add("BH", valBH);
                PressAct.Add("BL", valBL);

                // popolo valolri
                answ = new PlantDTO()
                {
                    LastUpdate = lastRec,
                    PlantId = PlantId,
                    PlantCode = currPlant.PlantCode,
                    PlantDesc = currPlant.PlantDesc,
                    LevelAct = actLevel,
                    LevelMax = currPlant.LevelMax,
                    LevelReorder = currPlant.LevelReorder,
                    OrderQtyStd = currPlant.OrderQtyStd,
                    PressAct = PressAct,
                    LevelTS = LevelTS,
                    PressTS = PressTS,
                    OrderTS = OrderTS
                };
            }
            return answ;
        }

        /// <summary>
        /// Recupero da DB l'ultimo record per ogni flusso
        /// </summary>
        /// <returns></returns>
        public List<PlantLogModel> PlantLogGetLastByFlux(int PlantId)
        {
            List<PlantLogModel> lastRec = dbCtx
                           .DbSetPlantLog
                           .Where(x => x.PlantId == PlantId)
                           .OrderByDescending(o => o.DtEvent)
                           .Take(1000)
                           .AsEnumerable()
                           .GroupBy(g => g.FluxType)
                           .Select(s => s.First())
                           .ToList();
            return lastRec;
        }

        /// <summary>
        /// Inserimento di un set di record x plant log
        /// </summary>
        /// <param name="PlantLogModel">Record da inserire (senza ID...)</param>
        /// <returns></returns>
        public bool PlantLogInsertNew(List<PlantLogModel> newItems)
        {
            bool fatto = false;
            try
            {
                dbCtx
                .DbSetPlantLog
                .AddRange(newItems);
                dbCtx.SaveChanges();
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error(exc, $"Eccezione durante PlantLogInsertNew per {newItems.Count} rec");
            }

            return fatto;
        }

        public bool RecordRebootLog(RebootLogModel newItem)
        {
            bool done = false;
            try
            {
                dbCtx
                    .DbRebootLog
                    .Add(newItem);
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            { }
            return done;
        }

        public void ResetController()
        {
            dbCtx = new GWMSContext(_configuration);
        }

        /// <summary>
        /// Annulla modifiche su una specifica entity (cancel update)
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool rollBackEntity(object item)
        {
            bool answ = false;
            try
            {
                if (dbCtx.Entry(item).State == EntityState.Deleted || dbCtx.Entry(item).State == EntityState.Modified)
                {
                    dbCtx.Entry(item).Reload();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Aggiorna un User
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool UserUpdate(UserModel updItem)
        {
            bool done = false;
            try
            {
                var currData = dbCtx
                    .DbSetUser
                    .Where(x => x.UserId == updItem.UserId)
                    .FirstOrDefault();
                if (currData != null)
                {
                    dbCtx.Entry(updItem).State = EntityState.Modified;
                }
                else
                {
                    dbCtx
                        .DbSetUser
                        .Add(updItem);
                }
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            { }
            return done;
        }

        /// <summary>
        /// Elimina un item WeekPlan
        /// </summary>
        /// <param name="selRecord"></param>
        /// <returns></returns>
        public bool WeekPlanDelete(WeekPlanModel selRecord)
        {
            bool done = false;
            try
            {
                var item2del = dbCtx
                    .DbSetPlantSupplWeekPlan
                    .Where(x => x.WeekPlanId == selRecord.WeekPlanId)
                    .FirstOrDefault();
                dbCtx.DbSetPlantSupplWeekPlan.Remove(item2del);
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            { }
            return done;
        }

        /// <summary>
        /// Aggiorna un item WeekPlan
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool WeekPlanUpdate(WeekPlanModel updItem)
        {
            bool done = false;
            try
            {
                var currData = dbCtx
                    .DbSetPlantSupplWeekPlan
                    .Where(x => x.WeekPlanId == updItem.WeekPlanId)
                    .FirstOrDefault();
                if (currData != null)
                {
                    dbCtx.Entry(updItem).State = EntityState.Modified;
                }
                else
                {
                    dbCtx
                        .DbSetPlantSupplWeekPlan
                        .Add(updItem);
                }
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            { }
            return done;
        }

        #endregion Public Methods
    }
}