Samuele Locatelli
744 lines
30 KiB
C#
744 lines
30 KiB
C#
using EgtBEAMWALL.DataLayer.DatabaseModels;
|
|
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using static EgtBEAMWALL.Core.ConstBeam;
|
|
|
|
namespace EgtBEAMWALL.DataLayer.Controllers
|
|
{
|
|
public class ProdController : IDisposable
|
|
{
|
|
#region Public Fields
|
|
|
|
public static ProdController man = new ProdController();
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public ProdController()
|
|
{
|
|
Log.Info("ProdController instance Started");
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Aggiunta di un PROJ ad un PROD
|
|
/// </summary>
|
|
/// <param name="ProdId">ID Prod</param>
|
|
/// <param name="ProjId">ID Proj</param>
|
|
/// <param name="UserKey">User ID / Key number</param>
|
|
/// <returns></returns>
|
|
public bool AddProj(int ProdId, int ProjId, string UserKey = "USER01")
|
|
{
|
|
bool done = false;
|
|
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
// cerco Prod
|
|
var currProd = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.FirstOrDefault();
|
|
|
|
// cerco Proj
|
|
var currProj = localDbCtx
|
|
.ProjList
|
|
.Where(x => x.ProjId == ProjId)
|
|
.FirstOrDefault();
|
|
|
|
// lo aggiorno
|
|
currProj.ProdDbId = currProd.ProdDbId;
|
|
currProj.Locked = true;
|
|
currProj.LockDate = DateTime.Now;
|
|
currProj.LockedBy = UserKey;
|
|
|
|
// salvo
|
|
localDbCtx.SaveChanges();
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public bool DeleteProd(int ProdId)
|
|
{
|
|
bool done = false;
|
|
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
var currProd = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
|
|
// sel dei proj da aggiornare...
|
|
var proj2update = localDbCtx
|
|
.ProjList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
// sel dei MachGroup da prod
|
|
var machGroup2del = localDbCtx
|
|
.MachGroupList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
// selezione dei part da machgroup
|
|
var part2del = localDbCtx
|
|
.PartList
|
|
.Where(x => x.MachGroup.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
try
|
|
{
|
|
// update proj...
|
|
foreach (var item in proj2update)
|
|
{
|
|
item.ProdDbId = null;
|
|
}
|
|
//// salvo
|
|
//localDbCtx.SaveChanges();
|
|
// remove from database
|
|
localDbCtx.PartList.RemoveRange(part2del);
|
|
//// salvo
|
|
//localDbCtx.SaveChanges();
|
|
localDbCtx.MachGroupList.RemoveRange(machGroup2del);
|
|
//// salvo
|
|
//localDbCtx.SaveChanges();
|
|
localDbCtx.ProdList.Remove(currProd);
|
|
// salvo
|
|
localDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string errMessage = $"EXCEPTION on Prod.DeleteProd: {Environment.NewLine}{exc}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get record by ProdDbId
|
|
/// </summary>
|
|
/// <param name="ProdDbId"></param>
|
|
/// <returns></returns>
|
|
public ProdModel FindByProdDbId(int ProdDbId)
|
|
{
|
|
ProdModel answ;
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
answ = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdDbId == ProdDbId)
|
|
.SingleOrDefault();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get record by ProdId
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <returns></returns>
|
|
public ProdModel FindByProdId(int ProdId)
|
|
{
|
|
ProdModel answ;
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
answ = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
}
|
|
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);
|
|
if (currProd == null)
|
|
{
|
|
return null;
|
|
}
|
|
return Core.ProdFileM.CreateProdFileM(currProd.ProdId, ProjIdByProd(ProdId), currProd.DtCreated, currProd.Description, currProd.PType, currProd.Machine, currProd.LockedBy, currProd.LockDate);
|
|
}
|
|
|
|
/// <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, x.PType, x.Machine, x.LockedBy, x.LockDate)).ToList();
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fornisce nuovo indice VUOTO da usare (allocando sul DB)
|
|
/// </summary>
|
|
/// <param name="ProjId">ID Proj</param>
|
|
/// <param name="UserKey">User ID / Key number</param>
|
|
/// <returns></returns>
|
|
public int GetNextIndex(int ProjId, string UserKey = "USER01")
|
|
{
|
|
int nextId = 0;
|
|
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
// cerco se ne ho ALMENO 1....
|
|
var numRec = localDbCtx.ProdList.Count();
|
|
if (numRec == 0)
|
|
{
|
|
nextId = 1;
|
|
}
|
|
else
|
|
{
|
|
// retrieve ultimo...
|
|
var maxRecord = localDbCtx
|
|
.ProdList
|
|
.OrderByDescending(x => x.ProdId)
|
|
.Take(1)
|
|
.FirstOrDefault();
|
|
// incremento
|
|
nextId = maxRecord.ProdId + 1;
|
|
}
|
|
|
|
// creo nuovo PROD...
|
|
var newProd = localDbCtx
|
|
.ProdList
|
|
.Add(new ProdModel() { ProdId = nextId, Locked = true, DtCreated = DateTime.Now });
|
|
|
|
// cerco Proj
|
|
var currProj = localDbCtx
|
|
.ProjList
|
|
.Where(x => x.ProjId == ProjId)
|
|
.FirstOrDefault();
|
|
|
|
// aggiungo proj-prod
|
|
currProj.ProdDbId = newProd.ProdDbId;
|
|
currProj.Locked = true;
|
|
currProj.LockDate = DateTime.Now;
|
|
currProj.LockedBy = UserKey;
|
|
|
|
// Commit changes
|
|
localDbCtx.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)
|
|
{
|
|
int numAssigned = 0;
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
// cerco se ci siano assegnati a supervisor
|
|
numAssigned = localDbCtx
|
|
.MachGroupList
|
|
.Where(x => x.Prod.ProdId == ProdId && (!string.IsNullOrEmpty(x.SupervisorId) || x.State >= 0))
|
|
.Count();
|
|
}
|
|
return numAssigned > 0;
|
|
}
|
|
|
|
/// <summary> Return Lock by ProdId (proj & prod) </summary> <param name="ProdId"></param> <returns></returns>
|
|
public bool IsLockByProdId(int ProdId)
|
|
{
|
|
bool bIsLock = false;
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
// seleziono il prod...
|
|
var currProd = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.FirstOrDefault();
|
|
|
|
if (currProd != null)
|
|
{
|
|
bIsLock = currProd.Locked;
|
|
|
|
var currProj = localDbCtx
|
|
.ProjList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
if (currProj != null && !bIsLock)
|
|
{
|
|
bIsLock = currProj.Any(x => x.Locked);
|
|
}
|
|
}
|
|
}
|
|
return bIsLock;
|
|
}
|
|
|
|
/// <summary> Manage Lock by ProdId (proj & prod) </summary> <param name="ProdId"></param>
|
|
/// <param name="Locked">Stato Lock da impostare</param> <param name="UserKey">User ID / Key
|
|
/// number</param> <returns></returns>
|
|
public ProdModel LockByProdId(int ProdId, bool Locked, string UserKey = "USER01")
|
|
{
|
|
ProdModel currProd;
|
|
// seleziono il prod...
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
currProd = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
|
|
if (currProd != null)
|
|
{
|
|
currProd.Locked = Locked;
|
|
currProd.LockDate = DateTime.Now;
|
|
currProd.LockedBy = Locked ? UserKey : "";
|
|
localDbCtx.Entry(currProd).State = System.Data.Entity.EntityState.Modified;
|
|
|
|
var currProj = localDbCtx
|
|
.ProjList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
//currProj.ForEach(x => x.Locked = Locked);
|
|
foreach (var item in currProj)
|
|
{
|
|
item.Locked = Locked;
|
|
item.LockDate = DateTime.Now;
|
|
item.LockedBy = Locked ? UserKey : "";
|
|
localDbCtx.Entry(item).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
}
|
|
|
|
localDbCtx.SaveChanges();
|
|
}
|
|
return currProd;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reinizializzaizone del controller
|
|
/// </summary>
|
|
public void ResetController()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update single PROD
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool Update(ProdModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
try
|
|
{
|
|
var item2update = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdDbId == updItem.ProdDbId)
|
|
.SingleOrDefault();
|
|
|
|
if (item2update != null)
|
|
{
|
|
// update, vers 1...
|
|
localDbCtx.Entry(item2update).CurrentValues.SetValues(updItem);
|
|
|
|
//// update, vers 2
|
|
//localDbCtx.PartList.Remove(item2del);
|
|
//localDbCtx.PartList.Add(updItem);
|
|
|
|
// Commit changes
|
|
localDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
else
|
|
{
|
|
string errMessage = $"ERROR on Prod.Update: req item was not found | ProdId {updItem.ProdId} | ProdDbId {updItem.ProdDbId} | Description {updItem.Description}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string errMessage = $"EXCEPTION on Prod.Update: {Environment.NewLine}{exc}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
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>Bool esecuzione con successo o meno</returns>
|
|
public bool UpdateMachGroup(int ProdId, List<Core.MyMachGroupM> MachGroupList)
|
|
{
|
|
bool testOk = false;
|
|
// calcolo occorrenze x ogni ID della barra...
|
|
var listaCheck = MachGroupList
|
|
.GroupBy(x => x.Id)
|
|
.Select(n => new
|
|
{
|
|
PartId = n.Key,
|
|
PartCount = n.Count()
|
|
})
|
|
.OrderBy(n => n.PartCount);
|
|
|
|
// controllo: nell'elenco delle barre MachGroupList NON devono esserci duplicati per
|
|
// l'ID (esterno) che deve essere univoco...
|
|
testOk = listaCheck.Where(x => x.PartCount > 1).Count() == 0;
|
|
if (testOk)
|
|
{
|
|
ProdModel currData = new ProdModel();
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
try
|
|
{
|
|
// Recupero il PROD nel contesto DB attuale
|
|
currData = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
|
|
if (currData != null)
|
|
{
|
|
// 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 = MachGroupController.man.FindByMachGroupId(ProdId, item.Id);
|
|
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
|
|
localDbCtx.SaveChanges();
|
|
// registro modifica StatusMap
|
|
StatusMapController.man.UpdateAction(currMG.SupervisorId, ProdId, currMG.MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
itemsMG2Add.Add(convCurrMG);
|
|
// registro modifica StatusMap
|
|
StatusMapController.man.UpdateAction("", ProdId, item.Id, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupAdd, "");
|
|
}
|
|
}
|
|
// aggiungo MachGroup
|
|
localDbCtx.MachGroupList.AddRange(itemsMG2Add);
|
|
// Commit changes
|
|
localDbCtx.SaveChanges();
|
|
|
|
// verifico di nuovo l'elenco delle MG x le relative PART...
|
|
foreach (var item in MachGroupList)
|
|
{
|
|
var currMG = MachGroupController.man.FindByMachGroupId(ProdId, item.Id);
|
|
int MachGroupDbId = currMG.MachGroupDbId;
|
|
bool modMg = false;
|
|
// verifico se uguali o meno...
|
|
foreach (var currPartM in item.PartMList)
|
|
{
|
|
var currPart = localDbCtx
|
|
.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
|
|
localDbCtx.SaveChanges();
|
|
modMg = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PartList2Add.Add(convCurrPartM);
|
|
modMg = true;
|
|
}
|
|
}
|
|
// verifico se salvare...
|
|
if (modMg)
|
|
{
|
|
StatusMapController.man.UpdateAction(currMG.SupervisorId, ProdId, currMG.MachGroupId, Core.StatusMapItemType.MachGroup, Core.StatusMapOpType.MachGroupMod, "");
|
|
}
|
|
}
|
|
|
|
// aggiungo PartList
|
|
localDbCtx.PartList.AddRange(PartList2Add);
|
|
// Commit changes
|
|
localDbCtx.SaveChanges();
|
|
|
|
// sel dei MachGroup da prod OLD
|
|
List<MachGroupModel> itemsMGOld = localDbCtx
|
|
.MachGroupList
|
|
.Where(x => x.Prod.ProdId == ProdId)
|
|
.ToList();
|
|
// elenco degli ID del MachGroup NON trovati
|
|
List<int> MgId2rem = itemsMGOld.Select(x => x.MachGroupId).Except(MachGroupList.Select(y => y.Id)).ToList();
|
|
// processo i MachGroup eliminati
|
|
foreach (var item in MgId2rem)
|
|
{
|
|
MachGroupController.man.Delete(ProdId, item);
|
|
}
|
|
|
|
// aggiorno valore isNew a false x PROD
|
|
currData.IsNew = false;
|
|
|
|
// Commit changes
|
|
localDbCtx.SaveChanges();
|
|
}
|
|
else
|
|
{
|
|
string errMessage = $"ERROR on Prod.UpdateMachGroup: req item was not found | ProdId {ProdId} | MachGroupList {MachGroupList.Count} rec";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string errMessage = $"EXCEPTION on Prod.UpdateMachGroup: {Environment.NewLine}{exc}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
}
|
|
return testOk;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update record su DB x PType
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <param name="Machine"></param>
|
|
/// <returns></returns>
|
|
public Core.ProdFileM UpdateMachine(int ProdId, String Machine)
|
|
{
|
|
ProdModel currData = new ProdModel();
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
try
|
|
{
|
|
currData = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
if (currData != null)
|
|
{
|
|
// aggiorno valore BTL
|
|
currData.Machine = Machine;
|
|
|
|
// Commit changes
|
|
localDbCtx.SaveChanges();
|
|
}
|
|
else
|
|
{
|
|
string errMessage = $"ERROR on Prod.UpdateMachine: req item was not found | ProdId {ProdId} | Machine {Machine}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string errMessage = $"EXCEPTION on Prod.UpdateMachine: {Environment.NewLine}{exc}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
return coreConv(currData);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update record su DB x PType
|
|
/// </summary>
|
|
/// <param name="ProdId"></param>
|
|
/// <param name="PType"></param>
|
|
/// <returns></returns>
|
|
public Core.ProdFileM UpdatePType(int ProdId, BWType PType)
|
|
{
|
|
ProdModel currData = new ProdModel();
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
try
|
|
{
|
|
currData = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.SingleOrDefault();
|
|
if (currData != null)
|
|
{
|
|
// aggiorno valore BTL
|
|
currData.PType = PType;
|
|
|
|
// Commit changes
|
|
localDbCtx.SaveChanges();
|
|
}
|
|
else
|
|
{
|
|
string errMessage = $"ERROR on Prod.UpdatePType: req item was not found | ProdId {ProdId} | PType {PType}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string errMessage = $"EXCEPTION on Prod.UpdatePType: {Environment.NewLine}{exc}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
return coreConv(currData);
|
|
}
|
|
|
|
/// <summary> Return User Code/Key that Locks by ProdId (proj & prod) </summary> <param
|
|
/// name="ProdId"></param> <returns></returns>
|
|
public string UserLockByProdId(int ProdId)
|
|
{
|
|
string LockBy = "";
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
try
|
|
{
|
|
// seleziono il prod...
|
|
var currProd = localDbCtx
|
|
.ProdList
|
|
.Where(x => x.ProdId == ProdId)
|
|
.FirstOrDefault();
|
|
|
|
if (currProd != null)
|
|
{
|
|
LockBy = currProd.LockedBy;
|
|
|
|
var currProj = localDbCtx
|
|
.ProjList
|
|
.Where(x => x.ProdDbId == currProd.ProdDbId)
|
|
.ToList();
|
|
|
|
if (currProj != null && string.IsNullOrEmpty(LockBy))
|
|
{
|
|
LockBy = currProj.FirstOrDefault(x => !string.IsNullOrEmpty(x.LockedBy)).LockedBy;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errMessage = $"ERROR on Prod.UserLockByProdId: req item was not found | ProdId {ProdId}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string errMessage = $"EXCEPTION on Prod.UserLockByProdId: {Environment.NewLine}{exc}";
|
|
Console.WriteLine(errMessage);
|
|
Log.Error(errMessage);
|
|
}
|
|
}
|
|
return LockBy;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Helper conversione modelli
|
|
/// </summary>
|
|
/// <param name="currProd"></param>
|
|
/// <returns></returns>
|
|
protected Core.ProdFileM coreConv(ProdModel currProd)
|
|
{
|
|
Core.ProdFileM answ = Core.ProdFileM.CreateProdFileM(currProd.ProdId, ProjIdByProd(currProd.ProdId), currProd.DtCreated, currProd.Description, currProd.PType, currProd.Machine, currProd.LockedBy, currProd.LockDate);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get LAST paginated data from DB (DESC ordered)
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
protected List<ProdModel> GetLastDbModelDesc(int numRecord)
|
|
{
|
|
using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
|
|
{
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = localDbCtx.ProdList.Count();
|
|
}
|
|
// retrieve
|
|
return localDbCtx
|
|
.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 Private Fields
|
|
|
|
/// <summary>
|
|
/// Istanza logger
|
|
/// </summary>
|
|
private NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |