egtbeamwall/EgtBEAMWALL.DataLayer/Controllers/StatusMapController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EgtBEAMWALL.DataLayer.DatabaseModels;

namespace EgtBEAMWALL.DataLayer.Controllers
{
    public class StatusMapController : IDisposable
    {
        #region Private Fields

        private DatabaseContext dbCtx;

        #endregion Private Fields

        #region Public Fields

        /// <summary>
        /// Oggetto statico per gestione chiamate da altre classi
        /// </summary>
        public static StatusMapController man = new StatusMapController();

        #endregion Public Fields

        #region Public Constructors

        public StatusMapController()
        {
            // Initialize database context
            dbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING);
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Elimina i dati di una sessione (SupervisorId) precedente
        /// </summary>
        /// <param name="Session">Se vuoto --> tutti</param>
        /// <returns></returns>
        public bool DeleteSession(string Session)
        {
            bool done = false;
            DateTime adesso = DateTime.Now;
            List<StatusMapModel> SM2Del = new List<StatusMapModel>();

            // svuoto la tab mappa precedente (da rivalutare in futuro)
            if (string.IsNullOrEmpty(Session))
            {
                SM2Del = dbCtx
                     .StatusMapList
                     .ToList();
            }
            else
            {
                SM2Del = dbCtx
                    .StatusMapList
                    .Where(x => x.Session == Session)
                    .ToList();
            }
            try
            {
                // Remove to database
                dbCtx.StatusMapList.RemoveRange(SM2Del);
                // Commit changes
                dbCtx.SaveChanges();
                ResetController();
                done = true;
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on DeleteSession: {exc}");
            }

            return done;
        }

        public void Dispose()
        {
            // Clear database context
            dbCtx.Dispose();
        }

        /// <summary>
        /// Get ALL data for session ordered by index DESC
        /// </summary>
        /// <param name="Session"></param>
        /// <returns></returns>
        public List<StatusMapModel> GetBySession(string Session = "")
        {
            // retrieve
            return dbCtx
                .StatusMapList
                .Where(x => x.Session == Session)
                .OrderByDescending(x => x.Index)
                .ToList();
        }

        /// <summary>
        /// Get data for session where Index > minIndex ordered by index DESC
        /// </summary>
        /// <param name="minIndex"></param>
        /// <returns></returns>
        public List<StatusMapModel> GetFrom(int minIndex = 0)
        {
            ResetController();
            // retrieve
            return dbCtx
                .StatusMapList
                .Where(x => x.Index >= minIndex)
                .OrderByDescending(x => x.Index)
                .ToList();
        }

        /// <summary>
        /// Get PROD data for session
        /// </summary>
        /// <returns></returns>
        public List<StatusMapModel> GetProd()
        {
            List<StatusMapModel> answ = new List<StatusMapModel>();
            // Initialize database context
            using (DatabaseContext myDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // retrieve
                answ = myDbCtx
                    .StatusMapList
                    .Where(x => x.ItemType == Core.StatusMapItemType.Prod)
                    .OrderByDescending(x => x.Index)
                    .ToList();
            }
            return answ;
#if false
            // retrieve
            return dbCtx
                .StatusMapList
                .Where(x => x.ItemType == Core.StatusMapItemType.Prod)
                .OrderByDescending(x => x.Index)
                .ToList(); 
#endif
        }

        /// <summary>
        /// Reinizializzaizone del controller
        /// </summary>
        public void ResetController()
        {
            // Re-Initialize database context
            dbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING);
        }

        /// <summary>
        /// Indica che si inizia a prendere in carico un PROD dal supervisor
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="ProjId"></param>
        /// <returns></returns>
        public bool StartProd(int ProdId, string SupervisorId)
        {
            bool done = false;
            DateTime adesso = DateTime.Now;

#if false
            // svuoto dati precedenti IN BLOCCO
            done = DeleteSession(""); 
#endif
            // gestione corretta x multi-supervisors
            done = DeleteSession(SupervisorId);

            // se ho fatto inserisco nuovo
            if (done)
            {
                // reset validità
                done = false;
                // inserisco dato prod
                StatusMapModel prodSMRecord = new StatusMapModel() { Session = SupervisorId, Index = 0, ItemId = ProdId, ItemType = Core.StatusMapItemType.Prod, Operation = Core.StatusMapOpType.Startup, DtEvent = adesso, Val = "" };
                // aggiungo
                dbCtx.StatusMapList.Add(prodSMRecord);

                // recupero MachGroup da PROD
                var MGList = dbCtx
                    .MachGroupList
                    .Where(x => x.Prod.ProdId == ProdId)
                    .ToList();

                var mgSMRecords = MGList.Select(x => new StatusMapModel() { Session = SupervisorId, Index = 0, ItemId = x.MachGroupId, ItemType = Core.StatusMapItemType.MachGroup, Operation = Core.StatusMapOpType.Startup, DtEvent = adesso, Val = "" }).ToList();
                // aggiungo
                dbCtx.StatusMapList.AddRange(mgSMRecords);

                // salvo
                dbCtx.SaveChanges();
                ResetController();
                done = true;
            }
            return done;
        }

        /// <summary>
        /// Aggiornamento di un record (e del prod) come da richiesta
        /// </summary>
        /// <param name="Session"></param>
        /// <param name="ProdId"></param>
        /// <param name="ItemId"></param>
        /// <param name="ItemType"></param>
        /// <param name="Operation"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public bool UpdateAction(String Session, int ProdId, int ItemId, Core.StatusMapItemType ItemType, Core.StatusMapOpType Operation, string Value)
        {
            bool fatto = false;
            // Recupero il record PROD (che è ultimo indice)
            StatusMapModel prodData = new StatusMapModel();
            // se è un prod --> vado x ID
            if (Session == "")
            {
                prodData = dbCtx
                    .StatusMapList
                    .Where(x => x.ItemType == Core.StatusMapItemType.Prod && x.ItemId == ProdId)
                    .SingleOrDefault();
            }
            else
            {
                prodData = dbCtx
                    .StatusMapList
                    .Where(x => x.ItemType == Core.StatusMapItemType.Prod && x.Session == Session)
                    .SingleOrDefault();
            }
            // se ho trovato
            if (prodData != null)
            {
                try
                {
                    // aggiorno indice PROD
                    prodData.Index++;

                    // vecchia versione
#if false
                    // recupero record richiesto
                    var currRecor = dbCtx
                    .StatusMapList
                    .Where(x => x.ItemType == ItemType && x.ItemId == ItemId && x.Session == Session)
                    .SingleOrDefault();

                    // aggiorno
                    currRecor.Index = prodData.Index;
                    currRecor.Operation = Operation;
                    currRecor.Val = Value;

#endif
                    // creo un nuovo record
                    DateTime adesso = DateTime.Now;
                    var newRec = new StatusMapModel() { Session = Session, Index = prodData.Index, ItemId = ItemId, ItemType = ItemType, Operation = Operation, DtEvent = adesso, Val = Value };
                    dbCtx.StatusMapList.Add(newRec);

                    // Commit changes
                    dbCtx.SaveChanges();
                    ResetController();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Console.WriteLine($"EXCEPTION on UpdateAction: {exc}");
                }
            }
            return fatto;
        }

        #endregion Public Methods
    }
}