Samuele Locatelli
1787 lines
69 KiB
C#
1787 lines
69 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using MP.MONO.Core.DTO;
|
|
using MP.MONO.Data.DbModels;
|
|
using MP.MONO.Data.DTO;
|
|
using NLog;
|
|
using System.Diagnostics;
|
|
using static MP.MONO.Core.Enums;
|
|
|
|
namespace MP.MONO.Data.Controllers
|
|
{
|
|
public class MpDbController : IDisposable
|
|
{
|
|
#region Public Constructors
|
|
|
|
public MpDbController(IConfiguration currAppConf)
|
|
{
|
|
appConf = currAppConf;
|
|
LogDurationLimitMs = appConf.GetValue<int>("OptPar:LogDurationLimitMs");
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Elenco records anagrafica allarmi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AlarmListModel> AlarmListGetAll()
|
|
{
|
|
List<AlarmListModel>? dbResult = new List<AlarmListModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
try
|
|
{
|
|
dbResult = localDbCtx
|
|
.DbSetAlarmList
|
|
.OrderBy(x => x.FullValue)
|
|
.ToList();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmListGetAll", exc);
|
|
}
|
|
LogDebug("AlarmListGetAll", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di un record anagrafica allarmi (o se esiste restituisce quello esistente)
|
|
/// </summary>
|
|
/// <param name="newItem">Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public AlarmListModel? AlarmListInsert(string alarmText)
|
|
{
|
|
AlarmListModel? foundRec = new AlarmListModel();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// verifico che NON esista con pèari descrizione...
|
|
foundRec = localDbCtx
|
|
.DbSetAlarmList
|
|
.FirstOrDefault(x => x.FullValue == alarmText);
|
|
// se non c'è aggiungo
|
|
if (foundRec == null)
|
|
{
|
|
foundRec = new AlarmListModel()
|
|
{
|
|
FullValue = alarmText
|
|
};
|
|
localDbCtx
|
|
.DbSetAlarmList
|
|
.Add(foundRec);
|
|
localDbCtx.SaveChanges();
|
|
// rifaccio search
|
|
foundRec = localDbCtx
|
|
.DbSetAlarmList
|
|
.FirstOrDefault(x => x.FullValue == alarmText);
|
|
}
|
|
LogDebug("AlarmListInsert", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmListInsert", exc);
|
|
}
|
|
}
|
|
return foundRec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di una lista record anagrafica allarmi
|
|
/// </summary>
|
|
/// <param name="newItems">Lista Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmListInsertMany(List<AlarmListModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
await localDbCtx
|
|
.DbSetAlarmList
|
|
.AddRangeAsync(newItems);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("AlarmListInsertMany", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmListInsertMany", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco allarmi (ultimi dato "skip")
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="skipRec"></param>
|
|
/// <param name="numRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmLogModel>> AlarmLogGetFilt(int MachineId, int skipRec, int numRec)
|
|
{
|
|
List<AlarmLogModel> dbResult = new List<AlarmLogModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = await localDbCtx
|
|
.DbSetAlarmLog
|
|
.AsNoTracking()
|
|
.Where(x => x.MachineId == MachineId)
|
|
.Include(m => m.MachineNav)
|
|
.OrderByDescending(x => x.AlarmLogId)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToListAsync();
|
|
|
|
LogDebug("AlarmLogGetFilt", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmLogGetFilt", exc);
|
|
}
|
|
}
|
|
//await Task.Delay(1);
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary> Recupero elenco allarmi con data <= alla data di riferimento (ultimi dato
|
|
/// "skip") </summary> <param name="MachineId"></param> <param name="dtRif"></param> <param
|
|
/// name="skipRec"></param> <param name="numRec"></param> <returns></returns>
|
|
public List<AlarmLogModel> AlarmLogGetFiltByDate(int MachineId, DateTime dtRif, int skipRec, int numRec)
|
|
{
|
|
List<AlarmLogModel> dbResult = new List<AlarmLogModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetAlarmLog
|
|
.AsNoTracking()
|
|
.Where(x => (x.MachineId == MachineId) && (x.DtRif <= dtRif))
|
|
.Include(m => m.MachineNav)
|
|
.OrderByDescending(x => x.AlarmLogId)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToList();
|
|
|
|
LogDebug("AlarmLogGetFiltByDate", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmLogGetFiltByDate", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di un record AlarmLog
|
|
/// </summary>
|
|
/// <param name="newItem">Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmLogInsert(AlarmLogModel newItem)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
localDbCtx
|
|
.DbSetAlarmLog
|
|
.Add(newItem);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
|
|
LogDebug("AlarmLogInsert", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmLogInsert", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di una lista record AlarmLog
|
|
/// </summary>
|
|
/// <param name="newItems">Lista Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmLogInsertMany(List<AlarmLogModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
if (newItems.Count > 0)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
await localDbCtx
|
|
.DbSetAlarmLog
|
|
.AddRangeAsync(newItems);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
LogInfo($"AlarmLogInsertMany| DB insert | {newItems.Count} rec", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmLogInsertMany", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude ultimo record dato Id (se fossero + di 1 chiude tutti...)
|
|
/// </summary>
|
|
/// <param name="AlarmId">Id Allarme</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmRecCloseActive(int AlarmId)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
DateTime adesso = DateTime.Now;
|
|
// prendo ultimi 10000 allarmi (odierni)
|
|
var lastAlarms = localDbCtx
|
|
.DbSetAlarmRec
|
|
.OrderByDescending(x => x.AlarmRecId)
|
|
.Take(10000)
|
|
.ToList();
|
|
|
|
var candList = lastAlarms
|
|
.Where(x => x.AlarmId == AlarmId && x.DtStart >= x.DtEnd)
|
|
.ToList();
|
|
if (candList.Count > 0)
|
|
{
|
|
foreach (var item in candList)
|
|
{
|
|
item.DtEnd = adesso;
|
|
}
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
LogDebug($"AlarmRecCloseActive | {candList.Count} closed", stopWatch.Elapsed);
|
|
}
|
|
else
|
|
{
|
|
LogDebug($"AlarmRecCloseActive | NONE", stopWatch.Elapsed);
|
|
}
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecCloseActive", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude ultimo record di allarmi aperti (avendo verificato sia zero da un pò...)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmRecCloseStarving()
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
DateTime adesso = DateTime.Now;
|
|
var lastAlarms = localDbCtx
|
|
.DbSetAlarmRec
|
|
.OrderByDescending(x => x.AlarmRecId)
|
|
.Take(100000)
|
|
.ToList();
|
|
|
|
var candList = lastAlarms
|
|
.Where(x => x.DtStart >= x.DtEnd)
|
|
.ToList();
|
|
foreach (var item in candList)
|
|
{
|
|
item.DtEnd = adesso;
|
|
}
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug($"AlarmRecCloseStarving", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecCloseStarving", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco allarmi Rec ATTIVI (non chiusi)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AlarmRecModel> AlarmRecGetActive()
|
|
{
|
|
List<AlarmRecModel> dbResult = new List<AlarmRecModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// recupero 10'000 allarme x limitare...
|
|
int numRec = localDbCtx
|
|
.DbSetAlarmRec
|
|
.Count();
|
|
|
|
int numMax = 10000;
|
|
int limitIdx = 0;
|
|
if (numRec > numMax)
|
|
{
|
|
var limitRec = localDbCtx
|
|
.DbSetAlarmRec
|
|
.AsNoTracking()
|
|
.OrderByDescending(x => x.AlarmRecId)
|
|
.Skip(numMax)
|
|
.Take(1)
|
|
.FirstOrDefault();
|
|
limitIdx = limitRec != null ? limitRec.AlarmRecId : 0;
|
|
|
|
}
|
|
dbResult = localDbCtx
|
|
.DbSetAlarmRec
|
|
//.AsNoTracking()
|
|
.Where(x => x.AlarmRecId > limitIdx && x.DtStart >= x.DtEnd)
|
|
.Include(m => m.AlarmListNav)
|
|
.ToList();
|
|
|
|
LogDebug("AlarmRecGetActive", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecGetActive", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco allarmi Rec (ultimi dato "skip")
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="skipRec"></param>
|
|
/// <param name="numRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmRecModel>> AlarmRecGetFilt(int MachineId, int skipRec, int numRec)
|
|
{
|
|
List<AlarmRecModel> dbResult = new List<AlarmRecModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = await localDbCtx
|
|
.DbSetAlarmRec
|
|
.AsNoTracking()
|
|
.Where(x => x.MachineId == MachineId)
|
|
.Include(m => m.MachineNav)
|
|
.Include(m => m.AlarmListNav)
|
|
.OrderByDescending(x => x.DtStart)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToListAsync();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("AlarmRecGetFilt", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecGetFilt", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary> Recupero elenco allarmi Rec con data <= a quella di riferimento(ultimi dato
|
|
/// "skip") </summary> <param name="MachineId"></param> <param name="dtRif"></param> <param
|
|
/// name="skipRec"></param> <param name="numRec"></param> <returns></returns>
|
|
public List<AlarmRecModel> AlarmRecGetFiltByDate(int MachineId, DateTime dtRif, int skipRec, int numRec)
|
|
{
|
|
List<AlarmRecModel> dbResult = new List<AlarmRecModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetAlarmRec
|
|
.AsNoTracking()
|
|
.Where(x => (x.MachineId == MachineId) && (x.DtStart <= dtRif))
|
|
.Include(m => m.MachineNav)
|
|
.Include(m => m.AlarmListNav)
|
|
.OrderByDescending(x => x.DtStart)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToList();
|
|
|
|
LogDebug("AlarmRecGetFiltByDate", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecGetFiltByDate", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero lista sommatoria durata eventi allarme per analisi, ordinati in logica di
|
|
/// pareto (Max-min)
|
|
/// </summary>
|
|
/// <param name="machineId">Id Macchina</param>
|
|
/// <param name="dtFrom">inizio analisi (evento deve iniziare/finire entro periodo)</param>
|
|
/// <param name="dtTo">fine analisi (evento deve iniziare/finire entro periodo)</param>
|
|
/// <param name="minDur">durata minima evento per venire considerato, -1 = tutti</param>
|
|
/// <param name="maxDur">durata massima evento per venire considerato, -1 = tutti</param>
|
|
/// <returns></returns>
|
|
public List<AlarmDurationDTO> AlarmRecGetParetoDur(int machineId, DateTime dtFrom, DateTime dtTo, int minDur = -1, int maxDur = -1)
|
|
{
|
|
List<AlarmDurationDTO> dbResult = new List<AlarmDurationDTO>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// effettuo il calcolo in + step...
|
|
var rawData = localDbCtx
|
|
.DbSetAlarmRec
|
|
.AsNoTracking()
|
|
.Where(x => x.MachineId == machineId
|
|
&& (x.DtStart >= dtFrom && x.DtStart <= dtTo)
|
|
&& (x.Duration >= minDur || minDur < 0)
|
|
&& (x.Duration <= maxDur || maxDur < 0))
|
|
.ToList();
|
|
|
|
dbResult = rawData
|
|
.GroupBy(g => g.AlarmId)
|
|
.Select(g => new AlarmDurationDTO() { MachineId = machineId, AlarmId = g.Key, Duration = g.Sum(x => x.Duration) })
|
|
.ToList()
|
|
.Join(
|
|
AlarmListGetAll(),
|
|
f => f.AlarmId,
|
|
l => l.AlarmId, (dur, list) => new AlarmDurationDTO()
|
|
{
|
|
AlarmId = dur.AlarmId,
|
|
Duration = dur.Duration,
|
|
MachineId = dur.MachineId,
|
|
AlarmDescription = list.FullValue
|
|
}
|
|
)
|
|
.OrderByDescending(o => o.Duration)
|
|
.ToList();
|
|
|
|
LogDebug("AlarmRecGetParetoDur", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecGetParetoDur", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero lista di conteggio eventi allarme per analisi, ordinati in logica di pareto (Max-min)
|
|
/// </summary>
|
|
/// <param name="machineId">Id Macchina</param>
|
|
/// <param name="dtFrom">inizio analisi (evento deve iniziare DOPO questa data)</param>
|
|
/// <param name="dtTo">fine analisi (evento deve iniziare prima di questa data)</param>
|
|
/// <param name="minDur">durata minima evento per venire considerato, -1 = tutti</param>
|
|
/// <param name="maxDur">durata massima evento per venire considerato, -1 = tutti</param>
|
|
/// <returns></returns>
|
|
public List<AlarmFreqDTO> AlarmRecGetParetoFreq(int machineId, DateTime dtFrom, DateTime dtTo, int minDur = -1, int maxDur = -1)
|
|
{
|
|
List<AlarmFreqDTO> dbResult = new List<AlarmFreqDTO>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetAlarmRec
|
|
.AsNoTracking()
|
|
.Where(x => x.MachineId == machineId
|
|
&& (x.DtStart >= dtFrom && x.DtStart <= dtTo)
|
|
&& (x.Duration >= minDur || minDur < 0)
|
|
&& (x.Duration <= maxDur || maxDur < 0))
|
|
.GroupBy(g => g.AlarmId)
|
|
.Select(g => new AlarmFreqDTO() { MachineId = machineId, AlarmId = g.Key, EventCount = g.Count() })
|
|
.ToList()
|
|
.Join(
|
|
AlarmListGetAll(),
|
|
f => f.AlarmId,
|
|
l => l.AlarmId, (freq, list) => new AlarmFreqDTO()
|
|
{
|
|
AlarmId = freq.AlarmId,
|
|
EventCount = freq.EventCount,
|
|
MachineId = freq.MachineId,
|
|
AlarmDescription = list.FullValue
|
|
}
|
|
)
|
|
.OrderByDescending(o => o.EventCount)
|
|
.ToList();
|
|
|
|
LogDebug("AlarmRecGetParetoFreq", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecGetParetoFreq", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di un record AlarmRec
|
|
/// </summary>
|
|
/// <param name="newItem">Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmRecInsert(AlarmRecModel newItem)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// verifico non sia già aperto... verifico eventuali items già aperti da NON
|
|
// dover aggiungere...
|
|
var stillOpenAlarms = localDbCtx
|
|
.DbSetAlarmRec
|
|
.Where(x => x.DtStart >= x.DtEnd && x.AlarmId == newItem.AlarmId)
|
|
.Select(x => x.AlarmId)
|
|
.ToList();
|
|
|
|
// se ho trovato --> salto!
|
|
if (stillOpenAlarms != null && stillOpenAlarms.Count > 0)
|
|
{
|
|
LogError($"Errore: trovato {stillOpenAlarms.Count} istanze già attive | Id: {newItem.AlarmId}");
|
|
}
|
|
else
|
|
{
|
|
localDbCtx
|
|
.DbSetAlarmRec
|
|
.Add(newItem);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
LogInfo($"AlarmRecInsert| DB insert 1 rec", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecInsert", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di una lista record AlarmRec
|
|
/// </summary>
|
|
/// <param name="newItems">Lista Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public bool AlarmRecInsertMany(List<AlarmRecModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
if (newItems.Count > 0)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// aggiungo
|
|
localDbCtx
|
|
.DbSetAlarmRec
|
|
.AddRange(newItems);
|
|
// salvo!
|
|
localDbCtx.SaveChanges();
|
|
fatto = true;
|
|
LogInfo($"AlarmRecInsertMany | DB insert | {newItems.Count} rec", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante AlarmRecInsertMany", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero counters da DB
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<CounterModel> CountersGetAll()
|
|
{
|
|
List<CounterModel> dbResult = new List<CounterModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetCounter
|
|
.AsNoTracking()
|
|
.ToList();
|
|
|
|
LogDebug($"CountersGetAll", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante CountersGetAll", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento/Update di una lista counters
|
|
/// </summary>
|
|
/// <param name="newItems">Lista Record da inserire</param>
|
|
/// <returns></returns>
|
|
public bool CountersUpsertMany(List<CounterModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
if (newItems.Count > 0)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// x ogni valore cerco...
|
|
foreach (var item in newItems)
|
|
{
|
|
var oldRec = localDbCtx
|
|
.DbSetCounter
|
|
.Where(x => x.CCode == item.CCode)
|
|
.FirstOrDefault();
|
|
if (oldRec == null)
|
|
{
|
|
localDbCtx
|
|
.DbSetCounter
|
|
.Add(item);
|
|
}
|
|
else
|
|
{
|
|
oldRec.ActualVal = item.ActualVal;
|
|
localDbCtx.Entry(oldRec).State = EntityState.Modified;
|
|
}
|
|
}
|
|
// salvo le modifiche
|
|
localDbCtx.SaveChanges();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
LogInfo($"CountersUpsertMany | DB insert | {newItems.Count} rec", stopWatch.Elapsed);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante CountersUpsertMany", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero DataLogDTO data condizione filtro
|
|
/// </summary>
|
|
/// <param name="machineId">ID macchina</param>
|
|
/// <param name="dataType">Tipologia di dato richiesto da enum</param>
|
|
/// <param name="fluxType">Tipo di Flusso</param>
|
|
/// <param name="inizio">DT Inizio estrazione</param>
|
|
/// <param name="fine">DT Fine estrazione</param>
|
|
/// <returns></returns>
|
|
public async Task<List<DataLogDTO>> DataLogDtoGetFilt(int machineId, DataLogType dataType, string fluxType, DateTime inizio, DateTime fine)
|
|
{
|
|
List<DataLogDTO> dbResult = new List<DataLogDTO>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = await localDbCtx
|
|
.DbSetDataLog
|
|
.Where(x => (x.MachineId == machineId) && (x.FluxType == fluxType) && (x.DataType == dataType || dataType == DataLogType.ND) && (x.DtRif >= inizio && x.DtRif <= fine))
|
|
.Select(r => new DataLogDTO() { DataLogId = r.DataLogId, DtRif = r.DtRif, ValNum = r.ValNum })
|
|
.OrderByDescending(x => x.DataLogId)
|
|
.ToListAsync();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("DataLogDtoGetFilt", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante DataLogDtoGetFilt", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero record DataLog data condizione filtro
|
|
/// </summary>
|
|
/// <param name="dataType">Tipologia di dato richiesto da enum</param>
|
|
/// <param name="inizio"></param>
|
|
/// <param name="fine"></param>
|
|
/// <param name="machineId"></param>
|
|
/// <param name="fluxType"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<DataLogModel>> DataLogGetFilt(DataLogType dataType, DateTime inizio, DateTime fine, int machineId, string fluxType)
|
|
{
|
|
List<DataLogModel> dbResult = new List<DataLogModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = await localDbCtx
|
|
.DbSetDataLog
|
|
.Where(x => (x.MachineId == machineId) && (x.FluxType == fluxType) && (x.DataType == dataType || dataType == DataLogType.ND) && (x.DtRif >= inizio && x.DtRif <= fine))
|
|
.Include(m => m.MachineNav)
|
|
.OrderByDescending(x => x.DataLogId)
|
|
.ToListAsync();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("DataLogGetFilt (5p)", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante DataLogGetFilt (5p)", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero record DataLog data condizione filtro (multi-flusso)
|
|
/// </summary>
|
|
/// <param name="dataType">Tipologia di dato richiesto da enum</param>
|
|
/// <param name="inizio"></param>
|
|
/// <param name="fine"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<DataLogModel>> DataLogGetFilt(DataLogType dataType, DateTime inizio, DateTime fine)
|
|
{
|
|
List<DataLogModel> dbResult = new List<DataLogModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = await localDbCtx
|
|
.DbSetDataLog
|
|
.Where(x => (x.DataType == dataType || dataType == DataLogType.ND) && (x.DtRif >= inizio && x.DtRif <= fine))
|
|
.Include(m => m.MachineNav)
|
|
.OrderByDescending(x => x.DataLogId)
|
|
.ToListAsync();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("DataLogGetFilt (3p)", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante DataLogGetFilt (3p)", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di un SET di record DataLog (post aggregazione base VC)
|
|
/// </summary>
|
|
/// <param name="newItems">Lista Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DataLogInsertMany(List<DataLogModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
await localDbCtx
|
|
.DbSetDataLog
|
|
.AddRangeAsync(newItems);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("DataLogInsertMany", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante DataLogInsertMany", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero record DataStAg (aggregati) data condizione filtro
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="FluxType"></param>
|
|
/// <param name="skipRec"></param>
|
|
/// <param name="numRec"></param>
|
|
/// <returns></returns>
|
|
public List<DataStAgModel> DataStAgGetFilt(int MachineId, string FluxType, int skipRec, int numRec)
|
|
{
|
|
List<DataStAgModel> dbResult = new List<DataStAgModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetDataStAg
|
|
.Where(x => x.MachineId == MachineId && x.FluxType == FluxType)
|
|
.Include(m => m.MachineNav)
|
|
.OrderByDescending(x => x.DataStAgId)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToList();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("DataStAgGetFilt", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante DataStAgGetFilt", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di un record DataStAg (aggregati) - creati da ANALYZER che effettua compattazione
|
|
/// </summary>
|
|
/// <param name="newItem">Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DataStAgInsert(DataStAgModel newItem)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
localDbCtx
|
|
.DbSetDataStAg
|
|
.Add(newItem);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("DataStAgInsert", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante DataStAgInsert", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database context
|
|
Log.Info("Dispose di MpDbController");
|
|
}
|
|
|
|
public ProductionDTO MachineGetProd()
|
|
{
|
|
// !!!FIXME TODO... è fake...
|
|
|
|
Random rand = new Random();
|
|
int stdCycle = 5;
|
|
|
|
ProductionDTO currMachDto = new ProductionDTO()
|
|
{
|
|
Order = "ODL Test",
|
|
ItemCode = "ART.0000123",
|
|
ProgName = "P000012",
|
|
CurrQty = DateTime.Now.Minute + rand.Next(1, 40),
|
|
OrderQty = 100,
|
|
CycleTimeMin = rand.NextDouble() * stdCycle,
|
|
Message = "...simulated data..."
|
|
};
|
|
|
|
Task.Delay(400).Wait();
|
|
|
|
return currMachDto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero pareto status impianto
|
|
/// </summary>
|
|
/// <param name="MachineId">Macchina selezionata</param>
|
|
/// <param name="from">inizio periodo</param>
|
|
/// <param name="to">fine periodo</param>
|
|
/// <returns></returns>
|
|
public List<ParetoStatusModel> ParetoStatusMach(int MachineId, DateTime from, DateTime to)
|
|
{
|
|
List<ParetoStatusModel> dbResult = new List<ParetoStatusModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetParetoStatus
|
|
.FromSqlRaw<ParetoStatusModel>("CALL stp_paretoStatus({0},{1},{2});", MachineId, from.ToString("yyyy-MM-dd"), to.ToString("yyyy-MM-dd"))
|
|
.ToList();
|
|
|
|
LogDebug("ParetoStatusMach", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante ParetoStatusMach", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco contatori ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<CounterModel> PMCounterModelGetAll()
|
|
{
|
|
List<CounterModel> dbResult = new List<CounterModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetCounter
|
|
.ToList();
|
|
|
|
LogDebug("PMCounterModelGetAll", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PMCounterModelGetAll", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco Gruppi Macchina PM ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<PMMGroupModel> PMMachGroupGetAll()
|
|
{
|
|
List<PMMGroupModel> dbResult = new List<PMMGroupModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetPMMachGroup
|
|
.ToList();
|
|
|
|
LogDebug("PMMachGroupGetAll", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PMMachGroupGetAll", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione Record
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <param name="forceDelete"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PMTaskDeleteRecord(PrevMaintTaskModel currRec, bool forceDelete)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var currVal = localDbCtx
|
|
.DbSetPMTask
|
|
.Where(x => x.PMTaskId == currRec.PMTaskId)
|
|
.FirstOrDefault();
|
|
if (currVal != null)
|
|
{
|
|
// se effettivo delete
|
|
if (forceDelete)
|
|
{
|
|
localDbCtx
|
|
.DbSetPMTask
|
|
.Remove(currVal);
|
|
}
|
|
else
|
|
{
|
|
currVal.IsDisabled = true;
|
|
}
|
|
await localDbCtx.SaveChangesAsync();
|
|
}
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("PMTaskDeleteRecord", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PMTaskDeleteRecord", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Riabilitazione task disabilitato
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PMTaskEnableRecord(PrevMaintTaskModel currRec)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var currVal = localDbCtx
|
|
.DbSetPMTask
|
|
.Where(x => x.PMTaskId == currRec.PMTaskId)
|
|
.FirstOrDefault();
|
|
if (currVal != null)
|
|
{
|
|
// se effettivo delete
|
|
if (currRec.IsDisabled)
|
|
{
|
|
currVal.IsDisabled = false;
|
|
}
|
|
await localDbCtx.SaveChangesAsync();
|
|
}
|
|
fatto = true;
|
|
|
|
LogDebug("PMTaskEnableRecord", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PMTaskEnableRecord", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco Topics PM ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<PMTaskTopicModel> PMTaskTopicGetAll()
|
|
{
|
|
List<PMTaskTopicModel> dbResult = new List<PMTaskTopicModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetPMTopic
|
|
.ToList();
|
|
|
|
LogDebug("PMTaskTopicGetAll", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PMTaskTopicGetAll", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco User Team PM ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<PMUTModel> PMUTeamGetAll()
|
|
{
|
|
List<PMUTModel> dbResult = new List<PMUTModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetUTeam
|
|
.ToList();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("PMUTeamGetAll", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PMUTeamGetAll", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco Task Manut Prev Previsti/Configurati (ultimi dato "skip")
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="skipRec"></param>
|
|
/// <param name="numRec"></param>
|
|
/// <returns></returns>
|
|
public List<PrevMaintTaskModel> PrevMaintTaskGetFilt(int MachineId, int skipRec, int numRec)
|
|
{
|
|
List<PrevMaintTaskModel> dbResult = new List<PrevMaintTaskModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetPMTask
|
|
.Where(x => x.MachineId == MachineId)
|
|
.Include(m => m.CounterNav)
|
|
.Include(m => m.MachGroupNav)
|
|
.Include(m => m.MachineNav)
|
|
.Include(m => m.TopicNav)
|
|
.Include(m => m.UserTeamNav)
|
|
.OrderBy(x => x.ExtIdx)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToList();
|
|
|
|
LogDebug("PrevMaintTaskGetFilt", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PrevMaintTaskGetFilt", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esegue update del record
|
|
/// </summary>
|
|
/// <param name="editRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PrevMaintTaskUpdate(PrevMaintTaskModel editRec)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var currRec = localDbCtx
|
|
.DbSetPMTask
|
|
.Where(x => x.PMTaskId == editRec.PMTaskId)
|
|
.FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
currRec.CCode = editRec.CCode;
|
|
currRec.ExpiryVal = editRec.ExpiryVal;
|
|
currRec.ExtIdx = editRec.ExtIdx;
|
|
currRec.PMMGCode = editRec.PMMGCode;
|
|
currRec.PMTCode = editRec.PMTCode;
|
|
currRec.PMUTCode = editRec.PMUTCode;
|
|
currRec.JobDescription = editRec.JobDescription;
|
|
localDbCtx.Entry(currRec).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
// se nuovo (user edit) --> NON protetto!
|
|
editRec.Protected = false;
|
|
localDbCtx
|
|
.DbSetPMTask
|
|
.Add(editRec);
|
|
}
|
|
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("PrevMaintTaskUpdate", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante PrevMaintTaskUpdate", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di una lista record Production Log
|
|
/// </summary>
|
|
/// <param name="newItems">Lista Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> ProdLogInsertMany(List<ProdLogModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
await localDbCtx
|
|
.DbSetProdLog
|
|
.AddRangeAsync(newItems);
|
|
await localDbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("ProdLogInsertMany", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante ProdLogInsertMany", exc);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua chiamata stored x pulizia dati stale/vecchi
|
|
/// </summary>
|
|
/// <param name="numDay2Keep"></param>
|
|
/// <returns></returns>
|
|
public List<TaskExecModel> RemoveOldData(int numDay2Keep)
|
|
{
|
|
List<TaskExecModel> dbResult = new List<TaskExecModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
try
|
|
{
|
|
dbResult = localDbCtx
|
|
.DbSetTaskExec
|
|
.FromSqlRaw<TaskExecModel>("CALL stp_removeOldData({0});", numDay2Keep)
|
|
.ToList();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("RemoveOldData", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante RemoveOldData", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// genera elenco Task Schedulati missing da schema + attualmente presenti...
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> SchedMaintTaskCreateMissing(int MachineId)
|
|
{
|
|
bool answ = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<PrevMaintTaskModel> missTask = new List<PrevMaintTaskModel>();
|
|
|
|
// elenco dei task NON disattivati
|
|
List<PrevMaintTaskModel>? allTask = localDbCtx
|
|
.DbSetPMTask
|
|
.Where(x => x.MachineId == MachineId && !x.IsDisabled)
|
|
.Include(i => i.CounterNav)
|
|
.ToList();
|
|
|
|
// analizzo task per idx del PMTask
|
|
var reqTask = allTask
|
|
.Select(x => x.PMTaskId)
|
|
.ToList();
|
|
|
|
var openTask = localDbCtx
|
|
.DbSetSMTask
|
|
.Where(x => x.DtExecution == DateTime.MinValue)
|
|
.Include(m => m.PMTaskeNav)
|
|
.ToList();
|
|
|
|
var currTask = openTask
|
|
.Where(x => x.PMTaskeNav.MachineId == MachineId)
|
|
.Select(x => x.PMTaskId)
|
|
.ToList();
|
|
|
|
// elenco dei SOLI task presenti
|
|
var listTaskOk = currTask.Intersect(reqTask).ToList();
|
|
|
|
// dall'elenco di quelli originali elimino presenti --> ho elenco mancanti...
|
|
foreach (var iTask in allTask)
|
|
{
|
|
// se non nell'elenco aggiungo...
|
|
if (!listTaskOk.Exists(x => x == iTask.PMTaskId))
|
|
{
|
|
missTask.Add(iTask);
|
|
}
|
|
}
|
|
|
|
var newRecs = missTask.Select(x => new PendingMaintModel()
|
|
{
|
|
CCode = x.CCode,
|
|
DtCreation = DateTime.Now,
|
|
ExpiryVal = x.ExpiryVal,
|
|
PMTaskId = x.PMTaskId,
|
|
CountStartVal = x.CounterNav.ActualVal
|
|
}).ToList();
|
|
|
|
localDbCtx
|
|
.DbSetSMTask
|
|
.AddRange(newRecs);
|
|
|
|
// salvo
|
|
localDbCtx.SaveChanges();
|
|
answ = true;
|
|
|
|
LogDebug("SchedMaintTaskCreateMissing", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante SchedMaintTaskGetFilt", exc);
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco Task Schedulati dati Macchina ed intervento "master"
|
|
/// </summary>
|
|
/// <param name="MachineId">Macchina selezionata</param>
|
|
/// <param name="PMTaskId">ID del PMTask parent</param>
|
|
/// <param name="skipRec">Num record da saltare</param>
|
|
/// <param name="numRec">num rec da recuperare</param>
|
|
/// <returns></returns>
|
|
public List<PendingMaintModel> SchedMaintTaskGetByPMTask(int MachineId, int PMTaskId, int skipRec, int numRec)
|
|
{
|
|
List<PendingMaintModel> dbResult = new List<PendingMaintModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetSMTask
|
|
.Include(i => i.CounterNav)
|
|
.Where(x => x.PMTaskeNav.MachineId == MachineId && x.PMTaskId == PMTaskId && x.DtExecution > DateTime.MinValue)
|
|
.Include(m => m.PMTaskeNav.MachGroupNav)
|
|
.Include(m => m.CounterNav)
|
|
.Include(m => m.PMTaskeNav.MachineNav)
|
|
.Include(m => m.PMTaskeNav.TopicNav)
|
|
.Include(m => m.PMTaskeNav.UserTeamNav)
|
|
.OrderByDescending(x => x.DtCreation)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToList();
|
|
|
|
LogDebug("SchedMaintTaskGetByPMTask", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante SchedMaintTaskGetByPMTask", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco Task Schedulati (ultimi dato "skip")
|
|
/// </summary>
|
|
/// <param name="MachineId">Macchina selezionata</param>
|
|
/// <param name="skipRec">Num record da saltare</param>
|
|
/// <param name="numRec">num rec da recuperare</param>
|
|
/// <returns></returns>
|
|
public List<PendingMaintModel> SchedMaintTaskGetFilt(int MachineId, int skipRec, int numRec)
|
|
{
|
|
List<PendingMaintModel> dbResult = new List<PendingMaintModel>();
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
dbResult = localDbCtx
|
|
.DbSetSMTask
|
|
.Include(i => i.CounterNav)
|
|
.Where(x => x.PMTaskeNav.MachineId == MachineId && x.DtExecution == DateTime.MinValue)
|
|
.Include(m => m.PMTaskeNav.MachGroupNav)
|
|
.Include(m => m.CounterNav)
|
|
.Include(m => m.PMTaskeNav.MachineNav)
|
|
.Include(m => m.PMTaskeNav.TopicNav)
|
|
.Include(m => m.PMTaskeNav.UserTeamNav)
|
|
.OrderBy(x => x.PMTaskeNav.ExtIdx)
|
|
.Skip(skipRec)
|
|
.Take(numRec)
|
|
.ToList();
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("SchedMaintTaskGetFilt", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante SchedMaintTaskGetFilt", exc);
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Registro esecuzione task schedualto
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="SMTaskId"></param>
|
|
/// <param name="ExecDT"></param>
|
|
/// <param name="ExecUser"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> SchedMaintTaskSetDone(int MachineId, int SMTaskId, DateTime ExecDT, string ExecUser)
|
|
{
|
|
bool answ = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// Aggiorno il task schedulato
|
|
var dbResult = localDbCtx
|
|
.DbSetSMTask
|
|
.Include(i => i.CounterNav)
|
|
.Where(x => x.PMTaskeNav.MachineId == MachineId && x.SMTaskId == SMTaskId)
|
|
.FirstOrDefault();
|
|
if (dbResult != null)
|
|
{
|
|
// aggiorno il record
|
|
dbResult.DtExecution = ExecDT;
|
|
dbResult.UserCode = ExecUser;
|
|
dbResult.ElapsedVal = dbResult.CounterNav.ActualVal - dbResult.CountStartVal;
|
|
|
|
// aggiorno il task parent col numero di task eseguiti...
|
|
int numDone = localDbCtx
|
|
.DbSetSMTask
|
|
.Where(x => x.PMTaskId == dbResult.PMTaskId)
|
|
.Count();
|
|
var parentRecord = localDbCtx
|
|
.DbSetPMTask
|
|
.Where(x => x.PMTaskId == dbResult.PMTaskId)
|
|
.FirstOrDefault();
|
|
if (parentRecord != null)
|
|
{
|
|
parentRecord.NumTaskDone = numDone;
|
|
}
|
|
|
|
// eseguo salvataggi!
|
|
localDbCtx.SaveChanges();
|
|
// segno fatto!
|
|
answ = true;
|
|
}
|
|
|
|
LogDebug("SchedMaintTaskSetDone", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante SchedMaintTaskSetDone", exc);
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserisce un nuovo record status log calcolando durata da rec precedente..
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> StatusLogInsert(StatusLogModel newRec)
|
|
{
|
|
bool answ = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
TimeSpan ts;
|
|
bool needInsert = false;
|
|
// ultimo inserito...
|
|
|
|
var lastSet = localDbCtx
|
|
.DbSetStatusLog
|
|
.Where(x => x.MachineId == newRec.MachineId)
|
|
.OrderByDescending(x => x.EventLogId)
|
|
.Take(50)
|
|
.ToList();
|
|
var lastRec = lastSet
|
|
.OrderByDescending(x => x.DtRif)
|
|
.FirstOrDefault();
|
|
|
|
// se non trovato inserisco comunque
|
|
if (lastRec == null)
|
|
{
|
|
needInsert = true;
|
|
}
|
|
// se trovato controllo variazione...
|
|
else
|
|
{
|
|
// se cambia stato...
|
|
if (lastRec.CodStatus != newRec.CodStatus)
|
|
{
|
|
needInsert = true;
|
|
}
|
|
// oppure se è passato il giorno...
|
|
else if (lastRec.DtRif.Date < newRec.DtRif.Date)
|
|
{
|
|
needInsert = true;
|
|
}
|
|
// calcolo durata vecchio record...
|
|
lastRec.Duration = (float)DateTime.Now.Subtract(lastRec.DtRif).TotalMinutes;
|
|
}
|
|
|
|
if (needInsert)
|
|
{
|
|
localDbCtx
|
|
.DbSetStatusLog
|
|
.Add(newRec);
|
|
|
|
// salvo se ho NUOVO record
|
|
localDbCtx.SaveChanges();
|
|
LogDebug("StatusLogInsert", stopWatch.Elapsed);
|
|
stopWatch.Stop();
|
|
}
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante StatusLogInsert", exc);
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Registrazione record esecuzione task x log
|
|
/// </summary>
|
|
/// <param name="recList"></param>
|
|
/// <returns></returns>
|
|
public bool TaskExecInsertLog(List<TaskExecModel> recList)
|
|
{
|
|
bool answ = false;
|
|
using (MapoMonoContext localDbCtx = new MapoMonoContext())
|
|
{
|
|
try
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
localDbCtx
|
|
.DbSetTaskExec
|
|
.AddRange(recList);
|
|
localDbCtx.SaveChanges();
|
|
answ = true;
|
|
stopWatch.Stop();
|
|
|
|
LogDebug("TaskExecInsertLog", stopWatch.Elapsed);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
LogException("Eccezione durante TaskExecInsertLog", exc);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Limite durata eventi loggati x passare comunque a livello INFO...
|
|
/// </summary>
|
|
private int LogDurationLimitMs = 2000;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
/// <summary>
|
|
/// Accessor configurazione
|
|
/// </summary>
|
|
private IConfiguration appConf { get; set; } = null!;
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Effettua Log tipo Debug
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="ts"></param>
|
|
private void LogDebug(string message, TimeSpan ts)
|
|
{
|
|
// Se superato limite --> invio a INFO
|
|
if (ts.TotalMilliseconds > LogDurationLimitMs)
|
|
{
|
|
LogInfo($"{message} | DurationLimit Exceeded", ts);
|
|
}
|
|
else
|
|
{
|
|
Log.Debug($"{message} | {ts.TotalMilliseconds} ms");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua Log tipo ERROR
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="exc">Eventuale exxeczione da traccaire</param>
|
|
private void LogError(string message)
|
|
{
|
|
Log.Error(message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua Log tipo ERROR
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="exc">Eventuale eccezione da tracciare</param>
|
|
private void LogException(string message, Exception exc)
|
|
{
|
|
Log.Error(exc, $"{message}{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua Log tipo TRACE
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="ts"></param>
|
|
private void LogInfo(string message, TimeSpan ts)
|
|
{
|
|
Log.Info($"{message} | {ts.TotalMilliseconds} ms");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua Log tipo TRACE
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="ts"></param>
|
|
private void LogTrace(string message, TimeSpan ts)
|
|
{
|
|
// Se superato limite --> invio a INFO
|
|
if (ts.TotalMilliseconds > LogDurationLimitMs)
|
|
{
|
|
LogInfo($"{message} | DurationLimit Exceeded", ts);
|
|
}
|
|
else
|
|
{
|
|
Log.Trace($"{message} | {ts.TotalMilliseconds} ms");
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |