Samuele Locatelli
475 lines
16 KiB
C#
475 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using EgtBEAMWALL.DataLayer.DatabaseModels;
|
|
|
|
namespace EgtBEAMWALL.DataLayer.Controllers
|
|
{
|
|
public class ProdController : IDisposable
|
|
{
|
|
#region Private Fields
|
|
|
|
private DatabaseContext dbCtx;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Public Fields
|
|
|
|
public static ProdController man = new ProdController();
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public ProdController()
|
|
{
|
|
// Initialize database context
|
|
dbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING);
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Get LAST paginated data from DB (DESC ordered)
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
protected List<ProdModel> GetLastDbModelDesc(int numRecord)
|
|
{
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.ProdList.Count();
|
|
}
|
|
// retrieve
|
|
return dbCtx
|
|
.ProdList
|
|
.OrderByDescending(x => x.ProdId)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
}
|
|
|
|
protected List<int> ProjIdByProd(int ProdId)
|
|
{
|
|
return DbManager.obj.ProjCtr.GetByProdAsc(ProdId).Select(y => y.nProjId).ToList();
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Aggiunta di un PROJ ad un PROD
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <param name="ProjId"></param>
|
|
/// <returns></returns>
|
|
public bool AddProj(int ProdId, int ProjId)
|
|
{
|
|
bool done = false;
|
|
|
|
// cerco Prod
|
|
var currProd = dbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.FirstOrDefault();
|
|
|
|
// cerco Proj
|
|
var currProj = dbCtx
|
|
.ProjList
|
|
.Where(x => x.ProjId == ProjId)
|
|
.FirstOrDefault();
|
|
|
|
// lo aggiorno
|
|
currProj.ProdDbId = currProd.ProdDbId;
|
|
currProj.Locked = true;
|
|
|
|
// salvo
|
|
dbCtx.SaveChanges();
|
|
ResetController();
|
|
|
|
return done;
|
|
}
|
|
|
|
public bool DeleteProd(int ProdId)
|
|
{
|
|
bool done = false;
|
|
|
|
var currProd = FindByProdId(ProdId);
|
|
|
|
// sel dei proj da aggiornare...
|
|
var proj2update = dbCtx
|
|
.ProjList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
// sel dei MachGroup da prod
|
|
var machGroup2del = dbCtx
|
|
.MachGroupList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
// selezione dei part da machgroup
|
|
var part2del = dbCtx
|
|
.PartList
|
|
.Where(x => x.MachGroup.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
try
|
|
{
|
|
// update proj...
|
|
foreach (var item in proj2update)
|
|
{
|
|
item.ProdDbId = null;
|
|
}
|
|
//// salvo
|
|
//dbCtx.SaveChanges();
|
|
// remove from database
|
|
dbCtx.PartList.RemoveRange(part2del);
|
|
//// salvo
|
|
//dbCtx.SaveChanges();
|
|
dbCtx.MachGroupList.RemoveRange(machGroup2del);
|
|
//// salvo
|
|
//dbCtx.SaveChanges();
|
|
dbCtx.ProdList.Remove(currProd);
|
|
// salvo
|
|
dbCtx.SaveChanges();
|
|
ResetController();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Console.WriteLine($"EXCEPTION on DeleteProd: {exc}");
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database context
|
|
dbCtx.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get record by ProdDbId
|
|
/// </summary>
|
|
/// <param name="ProdDbId"></param>
|
|
/// <returns></returns>
|
|
public ProdModel FindByProdDbId(int ProdDbId)
|
|
{
|
|
var answ = dbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdDbId == ProdDbId)
|
|
.SingleOrDefault();
|
|
// forzo rilettura
|
|
if (answ != null)
|
|
{
|
|
dbCtx.Entry(answ).Reload();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get record by ProdId
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <returns></returns>
|
|
public ProdModel FindByProdId(int ProdId)
|
|
{
|
|
var answ = dbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
// forzo rilettura
|
|
if (answ != null)
|
|
{
|
|
dbCtx.Entry(answ).Reload();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get record by ProdId ass Core.ProdFileM
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <returns></returns>
|
|
public Core.ProdFileM FindCoreByProdId(int ProdId)
|
|
{
|
|
var currProd = FindByProdId(ProdId);
|
|
|
|
return Core.ProdFileM.CreateProdFileM(currProd.ProdId, ProjIdByProd(ProdId), currProd.DtCreated, currProd.Description, Core.ConstBeam.BWType.NULL);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco progetti
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<Core.ProdFileM> GetLastDesc(int numRecord)
|
|
{
|
|
List<Core.ProdFileM> result = new List<Core.ProdFileM>();
|
|
var dbResult = GetLastDbModelDesc(numRecord);
|
|
// conversione
|
|
result = dbResult.Select(x => Core.ProdFileM.CreateProdFileM(x.ProdId, ProjIdByProd(x.ProdId), x.DtCreated, x.Description, Core.ConstBeam.BWType.NULL)).ToList();
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fornisce nuovo indice VUOTO da usare (allocando sul DB)
|
|
/// </summary>
|
|
/// <param name="ProjId"></param>
|
|
/// <returns></returns>
|
|
public int GetNextIndex(int ProjId)
|
|
{
|
|
int nextId = 0;
|
|
|
|
// cerco se ne ho ALMENO 1....
|
|
var numRec = dbCtx.ProdList.Count();
|
|
if (numRec == 0)
|
|
{
|
|
nextId = 1;
|
|
}
|
|
else
|
|
{
|
|
// retrieve ultimo...
|
|
var maxRecord = dbCtx
|
|
.ProdList
|
|
.OrderByDescending(x => x.ProdId)
|
|
.Take(1)
|
|
.FirstOrDefault();
|
|
// incremento
|
|
nextId = maxRecord.ProdId + 1;
|
|
}
|
|
|
|
// creo nuovo PROD...
|
|
var newProd = dbCtx
|
|
.ProdList
|
|
.Add(new ProdModel() { ProdId = nextId, Locked = true, DtCreated = DateTime.Now });
|
|
|
|
// cerco Proj
|
|
var currProj = dbCtx
|
|
.ProjList
|
|
.Where(x => x.ProjId == ProjId)
|
|
.FirstOrDefault();
|
|
|
|
// aggiungo proj-prod
|
|
currProj.ProdDbId = newProd.ProdDbId;
|
|
currProj.Locked = true;
|
|
|
|
// Commit changes
|
|
dbCtx.SaveChanges();
|
|
|
|
return nextId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica prod assegnato a supervisor:
|
|
/// ...se c'e' anche un solo machgroup del prod assegnato ad un supervisor o in stato 0 (dovrebbe essere la stessa cosa?)
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <returns></returns>
|
|
public bool IsAnyInSupervisor(int ProdId)
|
|
{
|
|
// cerco se ci siano assegnati a supervisor
|
|
var numAssigned = dbCtx
|
|
.MachGroupList
|
|
.Where(x => x.Prod.ProdId == ProdId && (!string.IsNullOrEmpty(x.SupervisorId) || x.State >= 0))
|
|
.Count();
|
|
|
|
return numAssigned > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Manage Lock by ProdId (proj & prod)
|
|
/// </summary>
|
|
/// <param name="ProdId">ProjID</param>
|
|
/// <param name="Locked">Stato Lock da impostare</param>
|
|
/// <returns></returns>
|
|
public ProdModel LockByProdId(int ProdId, bool Locked)
|
|
{
|
|
// seleziono il prod...
|
|
var currProd = dbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
|
|
if (currProd != null)
|
|
{
|
|
currProd.Locked = Locked;
|
|
dbCtx.Entry(currProd).State = System.Data.Entity.EntityState.Modified;
|
|
|
|
var currProj = dbCtx
|
|
.ProjList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
//currProj.ForEach(x => x.Locked = Locked);
|
|
foreach (var item in currProj)
|
|
{
|
|
item.Locked = Locked;
|
|
dbCtx.Entry(item).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
}
|
|
|
|
dbCtx.SaveChanges();
|
|
ResetController();
|
|
|
|
return currProd;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reinizializzaizone del controller
|
|
/// </summary>
|
|
public void ResetController()
|
|
{
|
|
// Re-Initialize database context
|
|
dbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update single PROD
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool Update(ProdModel updItem)
|
|
{
|
|
bool done = false;
|
|
var item2update = dbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdDbId == updItem.ProdDbId)
|
|
.SingleOrDefault();
|
|
try
|
|
{
|
|
// update, vers 1...
|
|
dbCtx.Entry(item2update).CurrentValues.SetValues(updItem);
|
|
|
|
//// update, vers 2
|
|
//dbCtx.PartList.Remove(item2del);
|
|
//dbCtx.PartList.Add(updItem);
|
|
|
|
// Commit changes
|
|
dbCtx.SaveChanges();
|
|
ResetController();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update record su DB x elenco MachGroup:
|
|
/// - NON vengono eliminati record (se ce ne son altri sul DB non saranno toccati)
|
|
/// - i record ESISTENTI (per MachGroup.ID) saranno aggiornati (tranne start/end/status)
|
|
/// - i record NON ESISTENTI (per MachGroup.ID) saranno AGGIUNTI (tranne start/end/status)
|
|
/// </summary>
|
|
/// <param name="ProdId">Id del Prod</param>
|
|
/// <param name="MachGroupList">Elenco MachGroup da associare</param>
|
|
/// <returns></returns>
|
|
public ProdModel UpdateMachGroup(int ProdId, List<Core.MyMachGroupM> MachGroupList)
|
|
{
|
|
// Recupero il PROD
|
|
ProdModel currData = FindByProdId(ProdId);
|
|
|
|
try
|
|
{
|
|
// preparo elenco
|
|
List<MachGroupModel> itemsMG2Add = new List<MachGroupModel>();
|
|
List<Core.MyMachGroupM> MachGroupList2Add = new List<Core.MyMachGroupM>();
|
|
List<PartModel> PartList2Add = new List<PartModel>();
|
|
// cerco le MG esistenti --> aggiorno
|
|
foreach (var item in MachGroupList)
|
|
{
|
|
var currMG = dbCtx
|
|
.MachGroupList
|
|
.Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == item.Id)
|
|
.SingleOrDefault();
|
|
var convCurrMG = MachGroupController.ConvertFromCore(item, currData.ProdDbId);
|
|
if (currMG != null)
|
|
{
|
|
// se non identico x equality limitata a ViewOptim...
|
|
if (!currMG.ViewOptimEquals(convCurrMG))
|
|
{
|
|
// aggiorno con nuovi valori ricevuti
|
|
currMG.H = convCurrMG.H;
|
|
currMG.L = convCurrMG.L;
|
|
currMG.W = convCurrMG.W;
|
|
currMG.Material = convCurrMG.Material;
|
|
currMG.Name = convCurrMG.Name;
|
|
// salvo
|
|
dbCtx.SaveChanges();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
itemsMG2Add.Add(convCurrMG);
|
|
}
|
|
}
|
|
// aggiungo MachGroup
|
|
dbCtx.MachGroupList.AddRange(itemsMG2Add);
|
|
// Commit changes
|
|
dbCtx.SaveChanges();
|
|
|
|
// verifico di nuovo l'elenco delle MG x le relative PART...
|
|
foreach (var item in MachGroupList)
|
|
{
|
|
int MachGroupDbId = MachGroupController.man.FindByMachGroupId(ProdId, item.Id).MachGroupDbId;
|
|
// verifico se uguali o meno...
|
|
foreach (var currPartM in item.PartMList)
|
|
{
|
|
var currPart = dbCtx
|
|
.PartList
|
|
.Where(x => x.MachGroup.Prod.ProdId == ProdId && x.MachGroup.MachGroupId == item.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();
|
|
ResetController();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Console.WriteLine($"EXCEPTION on UpdateMachGroup: {exc}");
|
|
}
|
|
|
|
return currData;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
} |