egtbeamwall/EgtBEAMWALL.DataLayer/Controllers/MachGroupController.cs

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

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

        private DatabaseContext dbCtx;

        #endregion Private Fields

        #region Public Fields

        public static MachGroupController man = new MachGroupController();

        #endregion Public Fields
        
        #region Public Constructors

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

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Conversion of base class to DB model class
        /// </summary>
        /// <param name="coreMachGroup"></param>
        /// <param name="currProdDbId"></param>
        /// <returns></returns>
        public static MachGroupModel ConvertFromCore(Core.MyMachGroupM coreMachGroup, int currProdDbId)
        {
            MachGroupModel answ = new MachGroupModel();
            if (coreMachGroup != null)
            {
                answ = new MachGroupModel()
                {
                    SupervisorId = "",
                    Name = coreMachGroup.Name,
                    Locked = true,
                    MachGroupId = coreMachGroup.Id,
                    ProdDbId = currProdDbId,
                    State = Core.ItemState.ND,
                    H = coreMachGroup.dH,
                    L = coreMachGroup.dL,
                    W = coreMachGroup.dW,
                    DtStart = coreMachGroup.dtStartTime,
                    DtEnd = coreMachGroup.dtEndTime,
                    Material = coreMachGroup.sMATERIAL,
                    // indice ordinale SOLO SE è >= 0
                    ProdIndex = coreMachGroup.nProdIndex >= 0 ? coreMachGroup.nProdIndex : 10000
                };
            }
            return answ;
        }

        /// <summary>
        /// Add MachGroup as rebuilt from NeedRedo (on top of order priority)
        /// <param name="ProdId">Id del Prod</param>
        /// <param name="newMachGroup">Nuovo MachGroup da associare</param>
        /// <returns></returns>
        public ProdModel AddMachGroupRedo(int ProdId, Core.MyMachGroupM newMachGroup)
        {
            // Recupero il PROD
            ProdModel currData = ProdController.man.FindByProdId(ProdId);
            List<PartModel> PartList2Add = new List<PartModel>();
            try
            {
                var convCurrMG = MachGroupController.ConvertFromCore(newMachGroup, currData.ProdDbId);

                convCurrMG.ProdIndex = 1;

                // aggiungo MachGroup
                dbCtx.MachGroupList.Add(convCurrMG);
                // Commit changes
                dbCtx.SaveChanges();

                int MachGroupDbId = MachGroupController.man.FindByMachGroupId(newMachGroup.Id).MachGroupDbId;
                // verifico se uguali o meno...
                foreach (var currPartM in newMachGroup.PartMList)
                {
                    var currPart = dbCtx
                      .PartList
                      .Where(x => x.MachGroup.Prod.ProdId == ProdId && x.MachGroup.MachGroupId == newMachGroup.Id && x.PartId == currPartM.nPartId)
                      .SingleOrDefault();
                    var convCurrPartM = PartController.ConvertFromCore(currPartM, MachGroupDbId);
                    if (currPart != null)
                    {
                        // se non identico x equality limitata a ViewOptim...
                        if (!currPart.ViewOptimEquals(convCurrPartM))
                        {
                            // aggiorno con nuovi valori ricevuti
                            currPart.H = convCurrPartM.H;
                            currPart.L = convCurrPartM.L;
                            currPart.W = convCurrPartM.W;
                            currPart.Material = convCurrPartM.Material;
                            currPart.CALC_State = convCurrPartM.CALC_State;
                            currPart.ROT = convCurrPartM.ROT;
                            currPart.PDN = convCurrPartM.PDN;
                            currPart.NAM = convCurrPartM.NAM;
                            // salvo
                            dbCtx.SaveChanges();
                        }
                    }
                    else
                    {
                        PartList2Add.Add(convCurrPartM);
                    }
                }

                // aggiungo PartList
                dbCtx.PartList.AddRange(PartList2Add);
                // Commit changes
                dbCtx.SaveChanges();

                // aggiorno valore isNew a false x PROD
                currData.IsNew = false;

                // Commit changes
                dbCtx.SaveChanges();
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, newMachGroup.Id, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupAdd, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateMachGroup: {exc}");
            }

            return currData;
        }

        /// <summary>
        /// Create record on DB
        /// </summary>
        /// <param name="newMachGroupId"></param>
        /// <param name="Name"></param>
        /// <returns></returns>
        public MachGroupModel Create(int newMachGroupId, string Name)
        {
            MachGroupModel newMachGroup = new MachGroupModel() { MachGroupId = newMachGroupId, Name = Name, State = Core.ItemState.ND };

            try
            {
                // Add to database
                dbCtx.MachGroupList.Add(newMachGroup);
                // Commit changes
                dbCtx.SaveChanges();
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on Create: {exc}");
            }

            return newMachGroup;
        }

        /// <summary>
        /// Delete MachGroup + Parts
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="MachGroupId"></param>
        /// <returns></returns>
        public bool Delete(int ProdId, int MachGroupId)
        {
            bool done = false;
            // inizio eliminando le part
            var parts2del = dbCtx
                .PartList
                .Where(x => x.MachGroup.Prod.ProdId == ProdId && x.MachGroup.MachGroupId == MachGroupId)
                .ToList();

            var MG2Del = dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .SingleOrDefault();

            try
            {
                // Remove to database
                dbCtx.PartList.RemoveRange(parts2del);
                dbCtx.MachGroupList.Remove(MG2Del);
                // Commit changes
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on Delete: ProdId: {ProdId} | MachGroupId: {MachGroupId}{Environment.NewLine}{exc}");
            }

            // se fatto aggiorno info sullo status
            StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupRem, "");

            return done;
        }

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

        /// <summary>
        /// Get record by MachGroupDbId
        /// </summary>
        /// <param name="MachGroupDbId"></param>
        /// <returns></returns>
        public MachGroupModel FindByMachGroupDbId(int MachGroupDbId)
        {
            return dbCtx
                .MachGroupList
                .Where(x => x.MachGroupDbId == MachGroupDbId)
                .SingleOrDefault();
        }

        /// <summary>
        /// Get record by MachGroupId
        /// </summary>
        /// <param name="MachGroupId"></param>
        /// <returns></returns>
        public MachGroupModel FindByMachGroupId(int MachGroupId)
        {
            return dbCtx
                .MachGroupList
                .Where(x => x.MachGroupId == MachGroupId)
                .SingleOrDefault();
        }

        /// <summary>
        /// Get filtered data by ProdId (ASC ordered)
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public List<MachGroupModel> GetByProdAsc(int ProdId)
        {
            // verificare fattibilità in 1 solo passo
            int ProdDbId = 0;
            try
            {
                var currProd = dbCtx
                    .ProdList
                    .Where(x => x.ProdId == ProdId)
                    .FirstOrDefault();
                if (currProd != null)
                {
                    ProdDbId = currProd.ProdDbId;
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on GetByProdAsc: {exc}");
            }
            return dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == ProdDbId)
                .OrderBy(x => x.ProdIndex)
                .ThenBy(x => x.MachGroupId)
                .ToList();
        }

        /// <summary>
        /// Get filtered data by MachGroupectId (DESC ordered)
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        public List<MachGroupModel> GetByProdDesc(int ProdId)
        {
            // recupero
            int ProdDbId = 0;

            // verificare fattibilità in 1 solo passo
            try
            {
                var currProd = dbCtx
                    .ProdList
                    .Where(x => x.ProdId == ProdId)
                    .FirstOrDefault();
                if (currProd != null)
                {
                    ProdDbId = currProd.ProdDbId;
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on GetByProdDesc: {exc}");
            }
            return dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == ProdDbId)
                .OrderByDescending(x => x.ProdIndex)
                .ThenByDescending(x => x.MachGroupId)
                .ToList();
        }

        /// <summary>
        /// Get filtered data by Assign (ASC ordered)
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="SupervisorId"></param>
        /// <returns></returns>
        public List<MachGroupModel> GetByProdSupervisor(int ProdId, string SupervisorId)
        {
            return dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.SupervisorId == SupervisorId)
                .OrderBy(x => x.ProdIndex)
                .ThenBy(x => x.MachGroupId)
                .ToList();
        }

        /// <summary>
        /// Set MachGroup as NeedRedo (ripresa = da rigenerare)
        /// </summary>
        /// <param name="MachGroupId"></param>
        /// <param name="newState"></param>
        /// <param name="Value">Value to save for regenerate</param>
        /// <returns></returns>
        public bool SetNeedRedo(int ProdId, int MachGroupId, Core.ItemState newState, string Value)
        {
            bool done = false;
            try
            {
                // aggiorno
                dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault()
                .State = newState;
                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupNeedRedo, Value);
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateStatus: {exc}");
            }

            return done;
        }

        /// <summary>
        /// Update single MachGroup
        /// </summary>
        /// <param name="updItem">Item to update (with updated values)</param>
        /// <returns></returns>
        public bool Update(MachGroupModel updItem)
        {
            bool done = false;
            var item2update = dbCtx
                .MachGroupList
                .Where(x => x.MachGroupDbId == updItem.MachGroupDbId)
                .SingleOrDefault();
            try
            {
                // update, vers 1...
                dbCtx.Entry(item2update).CurrentValues.SetValues(updItem);

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", updItem.Prod.ProdId, updItem.MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on Update: {exc}");
            }
            return done;
        }

        /// <summary>
        /// Set END for MachGroup
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="MachGroupId"></param>
        /// <param name="DtEnd"></param>
        /// <returns></returns>
        public bool UpdateEnd(int ProdId, int MachGroupId, DateTime DtEnd)
        {
            bool done = false;
            try
            {
                // aggiorno
                var currRecord = dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault();

                currRecord.DtEnd = DtEnd;

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateStartEnd: {exc}");
            }

            return done;
        }

        /// <summary>
        /// Set ProdIndex for MachGroup
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="MachGroupId"></param>
        /// <param name="newProdIndex"></param>
        /// <returns></returns>
        public bool UpdateOrder(int ProdId, int MachGroupId, int newProdIndex)
        {
            bool done = false;
            try
            {
                // aggiorno
                dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault()
                .ProdIndex = newProdIndex;
                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateOrder: {exc}");
            }

            return done;
        }

        /// <summary>
        /// Set START for MachGroup
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="MachGroupId"></param>
        /// <param name="PartId"></param>
        /// <param name="DtStart"></param>
        /// <returns></returns>
        public bool UpdateStart(int ProdId, int MachGroupId, DateTime DtStart)
        {
            bool done = false;
            try
            {
                // aggiorno
                var currRecord = dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault();

                currRecord.DtStart = DtStart;

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateStartEnd: {exc}");
            }

            return done;
        }

        /// <summary>
        /// Set START/END for MachGroup
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="MachGroupId"></param>
        /// <param name="DtStart"></param>
        /// <param name="DtEnd"></param>
        /// <returns></returns>
        public bool UpdateStartEnd(int ProdId, int MachGroupId, DateTime DtStart, DateTime DtEnd)
        {
            bool done = false;
            try
            {
                // aggiorno
                var currRecord = dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault();

                currRecord.DtStart = DtStart;
                currRecord.DtEnd = DtEnd;

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateStartEnd: {exc}");
            }

            return done;
        }

        /// <summary>
        /// Set Status for MachGroup
        /// </summary>
        /// <param name="MachGroupId"></param>
        /// <param name="newState"></param>
        /// <returns></returns>
        public bool UpdateStatus(int ProdId, int MachGroupId, Core.ItemState newState)
        {
            bool done = false;
            try
            {
                // aggiorno
                dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault()
                .State = newState;
                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateStatus: {exc}");
            }

            return done;
        }

        /// <summary>
        /// Set Supervisor & state for MachGroup
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="MachGroupId"></param>
        /// <param name="SupervisorId"></param>
        /// <returns></returns>
        public bool UpdateSupervisor(int ProdId, int MachGroupId, string SupervisorId)
        {
            bool done = false;
            try
            {
                // aggiorno
                var currRecord = dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == MachGroupId)
                .FirstOrDefault();

                currRecord.SupervisorId = SupervisorId;
                currRecord.State = Core.ItemState.Assigned;

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
                // aggiorno info sullo status
                StatusMapController.man.UpdateAction("", ProdId, MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateSupervisor: {exc}");
            }

            return done;
        }

        #endregion Public Methods
    }
}