egtbeamwall/EgtBEAMWALL.DataLayer/Controllers/RawItemsController.cs

using EgtBEAMWALL.DataLayer.DatabaseModels;
using EgwProxy.MagMan.DTO;
using NLog;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;

namespace EgtBEAMWALL.DataLayer.Controllers
{
    /// <summary>
    /// Gestione RawItem (barre) su DB (= magazzino locale)
    /// </summary>
    public class RawItemsController : IDisposable
    {
        #region Public Constructors

        public RawItemsController()
        {
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Helper conversion da DB model class a base class (VB)
        /// </summary>
        /// <param name="dbRec"></param>
        /// <returns></returns>
        public static Core.RawPartM ConvToCore(RawItemModel dbRec)
        {
            // converto in primis il materiale relativo
            Core.MaterialM matRec = MaterialsController.ConvToCore(dbRec.MaterialNav);
            Core.RawPartM answ = new Core.RawPartM(dbRec.RawItemId, matRec, (double)dbRec.WMm, (double)dbRec.LMm, dbRec.QtyAvail, dbRec.UseQty, dbRec.IsActive);
            return answ;
        }

        /// <summary>
        /// Helper conversione a ItemDTO
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public static ItemDTO ConvToItemDto(RawItemModel currRec)
        {
            ItemDTO answ = new ItemDTO()
            {
                MatCloudId = currRec.MaterialNav != null ? currRec.MaterialNav.MatCloudId : 0,
                MatLocalId = currRec.MatId,
                RawItemCloudId = currRec.RawItemCloudId,
                RawItemLocalId = currRec.RawItemId,
                IsRemn = currRec.IsRemn,
                QtyAvail = currRec.QtyAvail,
                HMm = currRec.HMm,
                LMm = currRec.LMm,
                WMm = currRec.WMm,
                Note = currRec.Note
            };
            return answ;
        }

        /// <summary>
        /// Helper conversione da ItemDTO
        /// </summary>
        /// <param name="currRec"></param>
        /// <param name="isActive"></param>
        /// <returns></returns>
        public static RawItemModel ConvToModel(ItemDTO currRec, bool isActive)
        {
            RawItemModel answ = new RawItemModel()
            {
                RawItemCloudId = currRec.RawItemCloudId,
                RawItemId = currRec.RawItemLocalId,
                QtyAvail = currRec.QtyAvail,
                HMm = currRec.HMm,
                LMm = currRec.LMm,
                WMm = currRec.WMm,
                MatId = currRec.MatLocalId,
                IsRemn = currRec.IsRemn,
                IsActive = isActive,
                UseQty = true,
                Note = currRec.Note
            };
            return answ;
        }

        /// <summary>
        /// Helper conversione da ResourceExpDTO
        /// </summary>
        /// <param name="currRec"></param>
        /// <param name="matLocalId"></param>
        /// <returns></returns>
        public static RawItemModel ConvToModel(ResourceExpDTO currRec, int matLocalId)
        {
            RawItemModel answ = new RawItemModel()
            {
                RawItemCloudId = currRec.RawItemCloudId,
                RawItemId = currRec.RawItemLocalId,
                QtyAvail = currRec.Qty,
                HMm = currRec.HMm,
                LMm = currRec.LMm,
                WMm = currRec.WMm,
                MatId = matLocalId,
                IsRemn = currRec.IsRemn,
                IsActive = currRec.IsActive,
                UseQty = true,
                Note = currRec.Note
            };
            return answ;
        }

        /// <summary>
        /// Conversion of base class to DB model class
        /// </summary>
        /// <param name="coreRec"></param>
        /// <returns></returns>
        public static RawItemModel ConvToModel(Core.RawPartM coreRec)
        {
            RawItemModel answ = new RawItemModel();
            if (coreRec != null)
            {
                answ = new RawItemModel()
                {
                    RawItemId = coreRec.nId,
                    MatId = coreRec.Material.nId,
                    HMm = (decimal)coreRec.Material.dH,
                    LMm = (decimal)coreRec.dL,
                    WMm = coreRec.dW > 0 ? (decimal)coreRec.dW : (decimal)coreRec.Material.dW,
                    IsActive = coreRec.bActive,
                    UseQty = coreRec.bUseQuantity,
                    QtyAvail = coreRec.nQuantity
                };
            }
            return answ;
        }

        /// <summary>
        /// Helper conversione a ResourceDTO
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public static ResourceDTO ConvToResDto(RawItemModel currRec)
        {
            ResourceDTO answ = new ResourceDTO()
            {
                RawItemCloudId = currRec.RawItemCloudId,
                RawItemLocalId = currRec.RawItemId,
                Qty = currRec.QtyAvail
            };
            return answ;
        }

        /// <summary>
        /// Helper conversione a ResourceDTO con garanzia valori Qty negativi
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public static ResourceDTO ConvToResDtoNeg(RawItemModel currRec)
        {
            ResourceDTO answ = new ResourceDTO()
            {
                RawItemCloudId = currRec.RawItemCloudId,
                RawItemLocalId = currRec.RawItemId,
                Qty = -Math.Abs(currRec.QtyAvail)
            };
            return answ;
        }

        /// <summary>
        /// Delete by key
        /// </summary>
        /// <param name="RawItemId"></param>
        /// <returns></returns>
        public bool DeleteByKey(int RawItemId)
        {
            bool done = false;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                var items2del = localDbCtx
                                    .RawItemList
                                    .Where(x => x.RawItemId == RawItemId);
                try
                {
                    // Add to database
                    localDbCtx.RawItemList.RemoveRange(items2del);
                    // Commit changes
                    localDbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"EXCEPTION on RawItems.DeleteByKey: {Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        public void Dispose()
        {
        }

        /// <summary>
        /// Get record by Key / Core
        /// </summary>
        /// <param name="RawItemId"></param>
        /// <returns></returns>
        public Core.RawPartM FindByDbId(int RawItemId)
        {
            var rawdata = FindByDbIdModel(RawItemId);
            var result = ConvToCore(rawdata);
            return result;
        }

        /// <summary>
        /// Get record by Key / Db Model
        /// </summary>
        /// <param name="RawItemId"></param>
        /// <returns></returns>
        public RawItemModel FindByDbIdModel(int RawItemId)
        {
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                return localDbCtx
                        .RawItemList
                        .Where(x => x.RawItemId == RawItemId)
                        .Include(m => m.MaterialNav)
                        .SingleOrDefault();
            }
        }

        /// <summary>
        /// Get Material (filtro x MatId) / Core
        /// </summary>
        /// <param name="MatId">0 = tutti</param>
        /// <returns></returns>
        public List<Core.RawPartM> GetFilt(int MatId)
        {
            var rawList = GetFiltModel(MatId);
            var result = rawList.Select(x => ConvToCore(x)).ToList();
            return result;
        }

        /// <summary>
        /// Get Material (filtro x MatId)
        /// </summary>
        /// <param name="MatId">0 = tutti</param>
        /// <returns></returns>
        public List<RawItemModel> GetFiltModel(int MatId)
        {
            // retrieve
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                return localDbCtx
                        .RawItemList
                        .Include(j => j.MaterialNav)
                        .Where(x => MatId == 0 || x.MatId == MatId)
                        .OrderBy(x => x.LMm)
                        .ThenBy(x => x.WMm)
                        .ToList();
            }
        }

        /// <summary>
        /// Update or insert RawItem record
        /// </summary>
        /// <param name="updItem">Recorda da registrare</param>
        /// <param name="changeUseQty">Indica se, in caso di modifica, vada aggiornato UseQty</param>
        /// <returns></returns>
        public int Upsert(RawItemModel updItem, bool changeUseQty)
        {
            int newIdx = 0;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    var item2update = localDbCtx
                                        .RawItemList
                                        .Where(x => (updItem.RawItemId > 0 && x.RawItemId == updItem.RawItemId)
                                                 || (x.MatId == updItem.MatId && x.WMm == updItem.WMm && x.HMm == updItem.HMm && x.LMm == updItem.LMm))
                                        .SingleOrDefault();

                    if (item2update != null)
                    {
                        //// update, vers 1...
                        //localDbCtx.Entry(item2update).CurrentValues.SetValues(updItem);
                        item2update.RawItemCloudId = updItem.RawItemCloudId;
                        item2update.QtyAvail = updItem.QtyAvail;
                        item2update.HMm = updItem.HMm;
                        item2update.LMm = updItem.LMm;
                        item2update.WMm = updItem.WMm;
                        item2update.IsActive = updItem.IsActive;
                        item2update.IsRemn = updItem.IsRemn;
                        if (changeUseQty)
                        {
                            item2update.UseQty = updItem.UseQty;
                        }
                        localDbCtx.Entry(item2update).State = EntityState.Modified;
                    }
                    else
                    {
                        localDbCtx.RawItemList.Add(updItem);
                    }
                    // Commit changes
                    localDbCtx.SaveChanges();
                    if (item2update != null)
                    {
                        newIdx = item2update.RawItemId;
                    }
                    else
                    {
                        newIdx = updItem.RawItemId;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"EXCEPTION on RawItems.Upsert: {Environment.NewLine}{exc}");
                }
            }
            return newIdx;
        }

        /// <summary>
        /// Update or insert RawItem record from CoreM
        /// </summary>
        /// <param name="coreItem"></param>
        /// <returns></returns>
        public int Upsert(Core.RawPartM coreItem)
        {
            int newIdx = 0;
            // converto
            RawItemModel updItem = ConvToModel(coreItem);
            newIdx = Upsert(updItem, true);
            return newIdx;
        }

        #endregion Public Methods

        #region Private Fields

        /// <summary>
        /// Istanza logger
        /// </summary>
        private NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields
    }
}