Samuele Locatelli
999 lines
42 KiB
C#
999 lines
42 KiB
C#
using MagMan.Core;
|
|
using MagMan.Core.DTO;
|
|
using MagMan.Data.Tenant.DbModels;
|
|
using MagMan.Data.Tenant.Services;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;
|
|
|
|
namespace MagMan.Data.Tenant.Controllers
|
|
{
|
|
public class TenantController : IDisposable
|
|
{
|
|
#region Public Constructors
|
|
|
|
public TenantController()
|
|
{
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
public async Task<bool> DatabaseMigrate(string connString)
|
|
{
|
|
bool answ = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
await dbCtx.Database.MigrateAsync();
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database context
|
|
Log.Info("Dispose di TenantController");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina Item da magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2del">Item da eliminare</param>
|
|
/// <returns></returns>
|
|
public bool ItemDelete(string connString, RawItemModel rec2del)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetItems
|
|
.Where(x => x.RawItemId == rec2del.RawItemId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx
|
|
.DbSetItems
|
|
.Remove(currData);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ItemDelete{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Items gestiti a magazzino (all)
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <returns></returns>
|
|
public List<RawItemModel> ItemGetAll(string connString)
|
|
{
|
|
List<RawItemModel> dbResult = new List<RawItemModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetItems
|
|
//.Where(x => CustomerId == 0 || x.CustomerID == CustomerId)
|
|
.Include(c => c.MaterialNav)
|
|
.OrderBy(x => x.MatId)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Items gestiti a magazzino dato Materiale
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="matID">ID del materiale x cui filtrare, 0 = tutti</param>
|
|
/// <returns></returns>
|
|
public List<RawItemModel> ItemGetByMat(string connString, int matID)
|
|
{
|
|
List<RawItemModel> dbResult = new List<RawItemModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetItems
|
|
.Where(x => matID == 0 || x.MatId == matID)
|
|
.Include(c => c.MaterialNav)
|
|
//.OrderBy(x => x.MatCloudId)
|
|
.OrderBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge/Modifica un item in magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2upd">Record da aggiornare</param>
|
|
/// <param name="deltaQty">quantità da aggiornare (se <0 è consumo)</param>
|
|
/// <param name="userId">User corrente (SE applicabile)</param>
|
|
/// <returns></returns>
|
|
public bool ItemModQty(string connString, RawItemModel rec2upd, int deltaQty, string userId)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
* Verifica se esistesse: deve essere valido TUTTO
|
|
* - stesso materiale
|
|
* - stesse dimensioni
|
|
* */
|
|
var currData = dbCtx
|
|
.DbSetItems
|
|
.Where(x => (x.RawItemId == rec2upd.RawItemId) ||
|
|
(x.MatId == rec2upd.MatId && (x.WMm == rec2upd.WMm && x.HMm == rec2upd.HMm && x.LMm == rec2upd.LMm)))
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
MovMagModel recMovMag = new MovMagModel()
|
|
{
|
|
DtRec = DateTime.Now,
|
|
RawItemId = rec2upd.RawItemId,
|
|
QtyRec = deltaQty,
|
|
UserId = userId,
|
|
Note = deltaQty > 0 ? "M01+: Rettifica Inventariale" : "M01-: Rettifica Inventariale"
|
|
};
|
|
dbCtx.DbSetMovMag.Add(recMovMag);
|
|
|
|
currData.QtyAvail += deltaQty;
|
|
dbCtx.Entry(currData).State = EntityState.Modified;
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ItemModQty{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge/Modifica un item in magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2upd">Record da aggiungere/aggiornare</param>
|
|
/// <param name="userId">User corrente (SE applicabile)</param>
|
|
/// <returns></returns>
|
|
public bool ItemUpdate(string connString, RawItemModel rec2upd, string userId)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
* Verifica se esistesse: deve essere valido TUTTO
|
|
* - stesso materiale
|
|
* - stesse dimensioni
|
|
* */
|
|
var currData = dbCtx
|
|
.DbSetItems
|
|
.Where(x => (x.RawItemId == rec2upd.RawItemId) ||
|
|
(x.MatId == rec2upd.MatId && (x.WMm == rec2upd.WMm && x.HMm == rec2upd.HMm && x.LMm == rec2upd.LMm)))
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
// aggiungo record variazione quantità...
|
|
int delta = rec2upd.QtyAvail - currData.QtyAvail;
|
|
if (delta != 0)
|
|
{
|
|
MovMagModel recMovMag = new MovMagModel()
|
|
{
|
|
DtRec = DateTime.Now,
|
|
RawItemId = rec2upd.RawItemId,
|
|
QtyRec = delta,
|
|
UserId = userId,
|
|
Note = delta > 0 ? "M02+: Rettifica Inventariale" : "M02-: Rettifica Inventariale"
|
|
};
|
|
dbCtx.DbSetMovMag.Add(recMovMag);
|
|
}
|
|
|
|
// sistemo record...
|
|
currData.MatId = rec2upd.MatId;
|
|
currData.QtyAvail = rec2upd.QtyAvail;
|
|
currData.IsActive = rec2upd.IsActive;
|
|
currData.IsRemn = rec2upd.IsRemn;
|
|
currData.Location = rec2upd.Location;
|
|
currData.LMm = rec2upd.LMm;
|
|
currData.HMm = rec2upd.HMm;
|
|
currData.WMm = rec2upd.WMm;
|
|
currData.Note = rec2upd.Note;
|
|
dbCtx.Entry(currData).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetItems
|
|
.Add(rec2upd);
|
|
dbCtx.SaveChanges();
|
|
|
|
// aggiungo record variazione quantità...
|
|
MovMagModel recMovMag = new MovMagModel()
|
|
{
|
|
DtRec = DateTime.Now,
|
|
RawItemId = rec2upd.RawItemId,
|
|
QtyRec = rec2upd.QtyAvail,
|
|
Note = rec2upd.QtyAvail > 0 ? "M03+: Aggiunta Record" : "M03+: Aggiunta Record"
|
|
};
|
|
dbCtx.DbSetMovMag.Add(recMovMag);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ItemUpdate{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina Materiale da magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2del">Item da eliminare</param>
|
|
/// <returns></returns>
|
|
public bool MaterialDelete(string connString, MaterialModel rec2del)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetMaterials
|
|
.Where(x => x.MatId == rec2del.MatId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx
|
|
.DbSetMaterials
|
|
.Remove(currData);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in MaterialDelete{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Materiali gestiti a magazzino formato DTO
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="withChild">Se true allora include record child (Items)</param>
|
|
/// <returns></returns>
|
|
public List<MaterialDTO> MaterialDtoGetAll(string connString, bool withChild)
|
|
{
|
|
List<MaterialDTO> dbResult = new List<MaterialDTO>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
// recupero modello base
|
|
var rawList = MaterialGetAll(connString, true);
|
|
// converto
|
|
if (rawList != null)
|
|
{
|
|
dbResult = rawList
|
|
.Select(x => new MaterialDTO()
|
|
{
|
|
MatCloudId = x.MatId,
|
|
MatCode = x.MatCode,
|
|
MatDesc = x.MatDesc,
|
|
HMm = x.HMm,
|
|
LMm = x.LMm,
|
|
WMm = x.WMm,
|
|
SizeNum = x.RawItemList == null ? 0 : x.RawItemList.Count,
|
|
QtyTot = x.RawItemList == null ? 0 : x.RawItemList.Sum(r => r.QtyAvail),
|
|
ItemList = withChild ? ItemsToDto(x.RawItemList != null ? x.RawItemList.ToList() : new List<RawItemModel>()) : new List<ItemDTO>()
|
|
})
|
|
.OrderBy(x => x.MatDesc)
|
|
.ThenBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Materiali gestiti a magazzino formato DTO
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="matID">Materiale richiesto, 0=tutti</param>
|
|
/// <param name="withChild">Se true allora include record child (Items)</param>
|
|
/// <returns></returns>
|
|
public List<MaterialDTO> MaterialDtoGetFilt(string connString, int matID, bool withChild)
|
|
{
|
|
List<MaterialDTO> dbResult = new List<MaterialDTO>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
// recupero modello base
|
|
var rawList = MaterialGetFilt(connString, matID, true);
|
|
// converto
|
|
if (rawList != null)
|
|
{
|
|
dbResult = rawList
|
|
.Select(x => new MaterialDTO()
|
|
{
|
|
MatCloudId = x.MatId,
|
|
MatCode = x.MatCode,
|
|
MatDesc = x.MatDesc,
|
|
HMm = x.HMm,
|
|
LMm = x.LMm,
|
|
WMm = x.WMm,
|
|
SizeNum = x.RawItemList == null ? 0 : x.RawItemList.Count,
|
|
QtyTot = x.RawItemList == null ? 0 : x.RawItemList.Sum(r => r.QtyAvail),
|
|
ItemList = withChild ? ItemsToDto(x.RawItemList != null ? x.RawItemList.ToList() : new List<RawItemModel>()) : new List<ItemDTO>()
|
|
})
|
|
.OrderBy(x => x.MatDesc)
|
|
.ThenBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converte il DTO in ItemModel
|
|
/// </summary>
|
|
/// <param name="origItem">DTO di partenza</param>
|
|
/// <param name="isActive">Parametro active da impostare</param>
|
|
/// <returns></returns>
|
|
public RawItemModel ItemFromDto(ItemDTO origItem, bool isActive)
|
|
{
|
|
RawItemModel answ = new RawItemModel()
|
|
{
|
|
MatId = origItem.MatCloudId,
|
|
IsRemn = origItem.IsRemn,
|
|
Location = origItem.Location,
|
|
QtyAvail = origItem.QtyAvail,
|
|
HMm = origItem.HMm,
|
|
LMm = origItem.LMm,
|
|
WMm = origItem.WMm,
|
|
Note = origItem.Note,
|
|
IsActive = isActive
|
|
};
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converte ItemModel in DTO
|
|
/// </summary>
|
|
/// <param name="origItem">ItemModel di partenza</param>
|
|
/// <returns></returns>
|
|
public ItemDTO ItemToDto(RawItemModel origItem)
|
|
{
|
|
ItemDTO answ = new ItemDTO()
|
|
{
|
|
MatCloudId = origItem.MatId,
|
|
RawItemCloudId = origItem.RawItemId,
|
|
IsRemn = origItem.IsRemn,
|
|
Location = origItem.Location,
|
|
QtyAvail = origItem.QtyAvail,
|
|
HMm = origItem.HMm,
|
|
LMm = origItem.LMm,
|
|
WMm = origItem.WMm,
|
|
Note = origItem.Note,
|
|
ItemDtmx = origItem.ItemDtmx
|
|
};
|
|
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Converte lista ItemModel in DTO
|
|
/// </summary>
|
|
/// <param name="origItem">Elenco ItemModel di partenza</param>
|
|
/// <returns></returns>
|
|
public List<ItemDTO> ItemsToDto(List<RawItemModel> origItem)
|
|
{
|
|
List<ItemDTO> answ = answ = origItem.Select(x => ItemToDto(x)).ToList();
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Materiali gestiti a magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <returns></returns>
|
|
public List<MaterialModel> MaterialGetAll(string connString, bool withChild)
|
|
{
|
|
List<MaterialModel> dbResult = new List<MaterialModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
if (withChild)
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMaterials
|
|
.Include(x => x.RawItemList)
|
|
.OrderBy(x => x.MatDesc)
|
|
.ThenBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMaterials
|
|
.OrderBy(x => x.MatDesc)
|
|
.ThenBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Materiali gestiti a magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="projDbId">Materiale richiesto, 0 = tutti</param>
|
|
/// <param name="withChild">Se true allora include record child (Items)</param>
|
|
/// <returns></returns>
|
|
public List<MaterialModel> MaterialGetFilt(string connString, int matID, bool withChild)
|
|
{
|
|
List<MaterialModel> dbResult = new List<MaterialModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
if (withChild)
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMaterials
|
|
.Where(x => matID == 0 || x.MatId == matID)
|
|
.Include(x => x.RawItemList)
|
|
.OrderBy(x => x.MatDesc)
|
|
.ThenBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMaterials
|
|
.Where(x => matID == 0 || x.MatId == matID)
|
|
.OrderBy(x => x.MatDesc)
|
|
.ThenBy(x => x.WMm)
|
|
.ThenBy(x => x.HMm)
|
|
.ThenBy(x => x.LMm)
|
|
.ToList();
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge/Modifica un Materiale in magazzino
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2upd">Record da aggiungere/aggiornare</param>
|
|
/// <returns></returns>
|
|
public bool MaterialUpdate(string connString, MaterialModel rec2upd)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
* Ricerca equal: corrisponde se
|
|
* - MatCloudId identico
|
|
* - se Uguali + NonNulli [MatCode oppure MatDescript] + uguali [W/H/L]...
|
|
*/
|
|
var currData = dbCtx
|
|
.DbSetMaterials
|
|
.Where(x => (rec2upd.MatId > 0 && x.MatId == rec2upd.MatId) ||
|
|
((x.WMm == rec2upd.WMm && x.HMm == rec2upd.HMm && x.LMm == rec2upd.LMm) &&
|
|
((!string.IsNullOrEmpty(rec2upd.MatCode) && x.MatCode == rec2upd.MatCode) || (!string.IsNullOrEmpty(rec2upd.MatDesc) && x.MatDesc == rec2upd.MatDesc))
|
|
))
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
currData.MatCode = rec2upd.MatCode;
|
|
currData.MatDesc = rec2upd.MatDesc;
|
|
currData.LMm = rec2upd.LMm;
|
|
currData.HMm = rec2upd.HMm;
|
|
currData.WMm = rec2upd.WMm;
|
|
dbCtx.Entry(currData).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetMaterials
|
|
.Add(rec2upd);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in MaterialUpdate{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco MovMag dato Item
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rawItemID">ID dell'item x cui filtrare, 0 = tutti</param>
|
|
/// <param name="maxRec">numMax record da leggere, default 1000</param>
|
|
/// <returns></returns>
|
|
public List<MovMagModel> MovMagGetFilt(string connString, int rawItemID, int maxRec = 1000)
|
|
{
|
|
List<MovMagModel> dbResult = new List<MovMagModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMovMag
|
|
.Where(x => rawItemID == 0 || x.RawItemId == rawItemID)
|
|
//.Include(c => c.ItemNav)
|
|
.OrderByDescending(x => x.DtRec)
|
|
.Take(maxRec)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina record Project
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2del">Item da eliminare</param>
|
|
/// <returns></returns>
|
|
public bool ProjectDelete(string connString, ProjModel rec2del)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetProjects
|
|
.Where(x => x.ProjDbId == rec2del.ProjDbId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx
|
|
.DbSetProjects
|
|
.Remove(currData);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ProjectDelete{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Projects (all)
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <returns></returns>
|
|
public List<ProjModel> ProjectGetAll(string connString)
|
|
{
|
|
List<ProjModel> dbResult = new List<ProjModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetProjects
|
|
.OrderBy(x => x.DtCreated)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco progetti dato cliente e macchina
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="machineID">ID macchina, 0 = tutti</param>
|
|
/// <returns></returns>
|
|
public List<ProjModel> ProjectGetByMachine(string connString, int machineID)
|
|
{
|
|
List<ProjModel> dbResult = new List<ProjModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetProjects
|
|
.Where(x => (machineID == 0 || x.MachineID == machineID))
|
|
.OrderBy(x => x.DtCreated)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Items gestiti a magazzino dato Materiale
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="numKey">ID master key, 0 = tutti</param>
|
|
/// <param name="numKey">periodo x filtraggio</param>
|
|
/// <returns></returns>
|
|
public List<ProjModel> ProjectGetFilt(string connString, int numKey, SelectData period)
|
|
{
|
|
List<ProjModel> dbResult = new List<ProjModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetProjects
|
|
.Where(x => (numKey == 0 || x.KeyNum == numKey) &&
|
|
((x.DtCreated >= period.DateStart && x.DtCreated <= period.DateEnd)
|
|
|| (x.DtSchedule >= period.DateStart && x.DtSchedule <= period.DateEnd)
|
|
|| (x.DtLastAction >= period.DateStart && x.DtLastAction <= period.DateEnd)
|
|
))
|
|
.OrderBy(x => x.DtCreated)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge/Modifica un record Project
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2upd">Record da aggiungere/aggiornare</param>
|
|
/// <returns></returns>
|
|
public bool ProjectUpdate(string connString, ProjModel rec2upd)
|
|
{
|
|
bool done = false;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
* Ricerca:
|
|
* - DbId corrisponde
|
|
* - Key + Id remoti corrispondono
|
|
* */
|
|
var currData = dbCtx
|
|
.DbSetProjects
|
|
.Where(x => (x.ProjDbId == rec2upd.ProjDbId) ||
|
|
(x.ProjExtDbId == rec2upd.ProjExtDbId && x.KeyNum == rec2upd.KeyNum) ||
|
|
(x.ProjExtId == rec2upd.ProjExtId && x.KeyNum == rec2upd.KeyNum))
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
currData.MachineID = rec2upd.MachineID;
|
|
currData.KeyNum = rec2upd.KeyNum;
|
|
currData.ProjExtDbId = rec2upd.ProjExtDbId;
|
|
currData.ProjExtId = rec2upd.ProjExtId;
|
|
currData.BTLFileName = rec2upd.BTLFileName;
|
|
currData.PType = rec2upd.PType;
|
|
currData.Machine = rec2upd.Machine;
|
|
currData.ProjDescription = rec2upd.ProjDescription;
|
|
currData.DtCreated = rec2upd.DtCreated;
|
|
currData.DtLastAction = rec2upd.DtLastAction;
|
|
currData.DtSchedule = rec2upd.DtSchedule;
|
|
currData.DtStartProd = rec2upd.DtStartProd;
|
|
currData.ListName = rec2upd.ListName;
|
|
currData.ProcTimeEst = rec2upd.ProcTimeEst;
|
|
currData.ProcTimeReal = rec2upd.ProcTimeReal;
|
|
currData.IsActive = rec2upd.IsActive;
|
|
currData.IsArchived = rec2upd.IsArchived;
|
|
dbCtx.Entry(currData).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetProjects
|
|
.Add(rec2upd);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ItemUpdate{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge/Modifica un record ReqPlan
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="rec2upd">Record da aggiungere/aggiornare</param>
|
|
/// <returns></returns>
|
|
public int ReqPlanUpdate(string connString, RequestPlanModel rec2upd)
|
|
{
|
|
int newId = 0;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
* Ricerca x Id corrispondente
|
|
* */
|
|
var currData = dbCtx
|
|
.DbSetReqPlan
|
|
.Where(x => x.RequestId == rec2upd.RequestId)
|
|
.FirstOrDefault();
|
|
|
|
// aggiorno
|
|
if (currData != null)
|
|
{
|
|
currData.ProjDbId = rec2upd.ProjDbId;
|
|
currData.DtRequest = rec2upd.DtRequest;
|
|
currData.ReqState = rec2upd.ReqState;
|
|
currData.IsActive = rec2upd.IsActive;
|
|
dbCtx.Entry(currData).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
// se NON di consumo prima rendo disattivi altri....
|
|
if (rec2upd.ReqState > Core.Enums.ProjResState.Consumed)
|
|
{
|
|
var rec2disable = dbCtx
|
|
.DbSetReqPlan
|
|
.Where(x => x.IsActive && x.ProjDbId == rec2upd.ProjDbId && x.ReqState > Core.Enums.ProjResState.Consumed)
|
|
.ToList();
|
|
if (rec2disable != null)
|
|
{
|
|
foreach (var recAct in rec2disable)
|
|
{
|
|
recAct.IsActive = false;
|
|
dbCtx.Entry(recAct).State = EntityState.Modified;
|
|
}
|
|
}
|
|
}
|
|
// aggiungo record
|
|
dbCtx
|
|
.DbSetReqPlan
|
|
.Add(rec2upd);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
newId = rec2upd.RequestId;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ReqPlanUpdate{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return newId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco risorse dato progetto e stato
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="projDbId">ID progetto</param>
|
|
/// <param name="isEstim">true = ultima stima attiva / false = consumi effettivi</param>
|
|
/// <returns></returns>
|
|
public List<ResourceExpDTO> ResourcesExpGetByProject(string connString, int projDbId, bool isEstim, bool showAll)
|
|
{
|
|
List<ResourceExpDTO> dbResult = new List<ResourceExpDTO>();
|
|
List<ResourceModel> rawData = new List<ResourceModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
if (isEstim)
|
|
{
|
|
rawData = dbCtx
|
|
.DbSetResources
|
|
.Include(p => p.RequestNav)
|
|
.Include(i => i.ItemNav)
|
|
.Where(x => x.RequestNav.ProjDbId == projDbId && (x.RequestNav.IsActive || showAll) && x.RequestNav.ReqState > Enums.ProjResState.ND)
|
|
.ToList();
|
|
}
|
|
else
|
|
{
|
|
rawData = dbCtx
|
|
.DbSetResources
|
|
.Include(p => p.RequestNav)
|
|
.Include(i => i.ItemNav)
|
|
.Where(x => x.RequestNav.ProjDbId == projDbId && x.RequestNav.IsActive && x.RequestNav.ReqState == Enums.ProjResState.Consumed)
|
|
.OrderBy(x => x.ResourceId)
|
|
.ToList();
|
|
}
|
|
try
|
|
{
|
|
dbResult = rawData.Select(x => new ResourceExpDTO()
|
|
{
|
|
ResourceCloudId = x.ResourceId,
|
|
RawItemCloudId = x.RawItemId,
|
|
Qty = x.Qty,
|
|
Note = x.ItemNav.Note,
|
|
DtRequest = x.RequestNav.DtRequest,
|
|
HMm = x.ItemNav.HMm,
|
|
LMm = x.ItemNav.LMm,
|
|
WMm = x.ItemNav.WMm,
|
|
IsActive = x.RequestNav.IsActive,
|
|
IsRemn = x.ItemNav.IsRemn,
|
|
MatCloudId = x.ItemNav.MatId,
|
|
RequestId = x.RequestId
|
|
})
|
|
.OrderByDescending(x => x.DtRequest)
|
|
.ThenByDescending(x => x.ResourceCloudId)
|
|
.ToList();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione ResourcesExpGetByProject{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco risorse dato progetto e stato
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="projDbId">ID progetto</param>
|
|
/// <param name="isEstim">true = ultima stima attiva / false = consumi effettivi</param>
|
|
/// <returns></returns>
|
|
public List<ResourceModel> ResourcesGetByProject(string connString, int projDbId, bool isEstim, bool showAll)
|
|
{
|
|
List<ResourceModel> dbResult = new List<ResourceModel>();
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
if (isEstim)
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetResources
|
|
.Where(x => x.RequestNav.ProjDbId == projDbId && (x.RequestNav.IsActive || showAll) && x.RequestNav.ReqState > Enums.ProjResState.ND)
|
|
.OrderBy(x => x.ResourceId)
|
|
.ToList();
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetResources
|
|
.Where(x => x.RequestNav.ProjDbId == projDbId && x.RequestNav.IsActive && x.RequestNav.ReqState == Enums.ProjResState.Consumed)
|
|
.OrderBy(x => x.ResourceId)
|
|
.ToList();
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge/Modifica un elenco di Resource (+ eventuali update giacenze)
|
|
/// </summary>
|
|
/// <param name="connString">Stringa connessione (variabile x cliente)</param>
|
|
/// <param name="recList">Elenco record da aggiungere/aggiornare</param>
|
|
/// <param name="resState">Tipo di aggiornamento da registratre</param>
|
|
/// <param name="userId">User corrente (SE applicabile)</param>
|
|
/// <returns></returns>
|
|
public int ResourceUpdate(string connString, List<ResourceModel> recList, Enums.ProjResState resState, string userId)
|
|
{
|
|
int numMod = 0;
|
|
using (MagManContext dbCtx = new MagManContext(connString))
|
|
{
|
|
try
|
|
{
|
|
foreach (var rec2upd in recList)
|
|
{
|
|
/*
|
|
* Ricerca x Id corrispondente
|
|
* */
|
|
var currData = dbCtx
|
|
.DbSetResources
|
|
.Where(x => rec2upd.ResourceId > 0 && x.ResourceId == rec2upd.ResourceId)
|
|
.FirstOrDefault();
|
|
|
|
// aggiorno
|
|
if (currData != null)
|
|
{
|
|
if (resState == Enums.ProjResState.Consumed)
|
|
{
|
|
// aggiungo record variazione quantità...
|
|
int delta = rec2upd.Qty - currData.Qty;
|
|
if (delta != 0)
|
|
{
|
|
MovMagModel recMovMag = new MovMagModel()
|
|
{
|
|
DtRec = DateTime.Now,
|
|
RawItemId = rec2upd.RawItemId,
|
|
QtyRec = delta,
|
|
UserId = userId,
|
|
Note = delta > 0 ? "M04+: Aggiunta Risorsa" : "M04-: Consumo Risorsa"
|
|
};
|
|
dbCtx.DbSetMovMag.Add(recMovMag);
|
|
}
|
|
}
|
|
|
|
// aggiorno le risorse
|
|
currData.Qty = rec2upd.Qty;
|
|
currData.RawItemId = rec2upd.RawItemId;
|
|
dbCtx.Entry(currData).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
if (resState == Enums.ProjResState.Consumed)
|
|
{
|
|
// aggiungo record variazione quantità...
|
|
MovMagModel recMovMag = new MovMagModel()
|
|
{
|
|
DtRec = DateTime.Now,
|
|
RawItemId = rec2upd.RawItemId,
|
|
QtyRec = rec2upd.Qty,
|
|
UserId = userId,
|
|
Note = rec2upd.Qty > 0 ? "M05+: Aggiunta Risorsa" : "M05-: Consumo Risorsa"
|
|
};
|
|
dbCtx.DbSetMovMag.Add(recMovMag);
|
|
}
|
|
|
|
// aggiungo record
|
|
dbCtx
|
|
.DbSetResources
|
|
.Add(rec2upd);
|
|
}
|
|
// se si tratta di consumo --> aggiorno giacenze!
|
|
if (resState == Enums.ProjResState.Consumed)
|
|
{
|
|
// cerco record giacenza da aggiornare...
|
|
|
|
var recGiac = dbCtx
|
|
.DbSetItems
|
|
.Where(x => x.RawItemId == rec2upd.RawItemId)
|
|
.FirstOrDefault();
|
|
if (recGiac != null)
|
|
{
|
|
recGiac.QtyAvail += rec2upd.Qty;
|
|
dbCtx.Entry(recGiac).State = EntityState.Modified;
|
|
}
|
|
}
|
|
numMod++;
|
|
}
|
|
// salvo su DB
|
|
dbCtx.SaveChanges();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in ResourceUpdate{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return numMod;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |