NKC/REMAN/NKC.Data/Controllers/NKCController.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NKC.Data.DbModels;
using NKC.Data.DTO;
using NLog;

namespace NKC.Data.Controllers
{
    public class NKCController : IDisposable
    {
        #region Private Fields

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

        #endregion Private Fields

        #region Public Constructors

        public NKCController(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        #endregion Public Constructors

        #region Public Methods

        public bool DbForceMigrate()
        {
            bool answ = false;
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                try
                {
                    localDbCtx.DbForceMigrate();
                    answ = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in DbForceMigrate");
                }
            }
            return answ;
        }

        public void Dispose()
        {
            Log.Info("Dispose di NKCController");
        }

        public List<MaterialDTO> MaterialsGetAll()
        {
            List<MaterialDTO> dbResult = new List<MaterialDTO>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetMaterials
                .Where(x => x.MatID > 0)
                .Select(x => new MaterialDTO()
                {
                    MatID = x.MatID,
                    MatExtCode = x.MatExtCode,
                    MatDesc = x.MatDesc,
                    LMm = x.LMm,
                    WMm = x.WMm,
                    TMm = x.TMm,
                    ApprovUser = x.ApprovUser,
                    ApprovDate = x.ApprovDate,
                    NumSize = x.RemnantNav.Count,
                    TotQty = x.RemnantNav.Sum(r => r.QtyAvail)
                }
                )
                .ToList();
            }
            return dbResult;
        }

        public List<RemnantsModel> RemnantsGetAll()
        {
            List<RemnantsModel> dbResult = new List<RemnantsModel>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetRemnants
                .ToList();
            }
            return dbResult;
        }

        public List<RemnantsModel> RemnantsGetFilt(int matId, int minQty)
        {
            List<RemnantsModel> dbResult = new List<RemnantsModel>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetRemnants
                .Where(x => (x.MatID == matId || matId == 0) && (x.QtyAvail >= minQty || minQty == 0))
                //.OrderBy(o => o.Area)
                .Include(m => m.MaterialNav)
                .ToList();
            }
            return dbResult;
        }

        public bool RemnantsUpsert(RemnantsModel updItem)
        {
            bool done = false;
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                
                try
                {
                    RemnantsModel currData = localDbCtx
                       .DbSetRemnants
                       .Where(x => x.RemnID == updItem.RemnID)
                       .FirstOrDefault();
                    if (currData != null)
                    {
                        // aggiungo record variazione quantità...
                        int delta = updItem.QtyAvail - currData.QtyAvail;
                        MovMagModel recMovMag = new MovMagModel()
                        {
                            DtRec=DateTime.Now,
                            RemnID=updItem.RemnID,
                            QtyRec=delta
                        };
                        localDbCtx.DbSetMovMag.Add(recMovMag);

                        // aggiorno valori
                        currData.MatID = updItem.MatID;
                        currData.DtMod = updItem.DtMod;
                        currData.Location = updItem.Location;
                        currData.Note = updItem.Note;
                        currData.QtyAvail = updItem.QtyAvail;
                        currData.LMm = updItem.LMm;
                        currData.WMm = updItem.WMm;
                        currData.TMm = updItem.TMm;
                        localDbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        // aggiungo record variazione quantità...
                        MovMagModel recMovMag = new MovMagModel()
                        {
                            DtRec = DateTime.Now,
                            RemnID = updItem.RemnID,
                            QtyRec = updItem.QtyAvail
                        };
                        localDbCtx.DbSetMovMag.Add(recMovMag);

                        // aggiungo record puntuale
                        currData = new RemnantsModel()
                        {
                            MatID = updItem.MatID,
                            DtMod = updItem.DtMod,
                            Location = updItem.Location,
                            Note = updItem.Note,
                            QtyAvail = updItem.QtyAvail,
                            LMm = updItem.LMm,
                            WMm = updItem.WMm,
                            TMm = updItem.TMm
                        };
                        localDbCtx
                            .DbSetRemnants
                            .Add(currData);
                    }
                    localDbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in PlantUpdate:{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

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

        #endregion Public Methods
    }
}