Samuele Locatelli
1617 lines
63 KiB
C#
1617 lines
63 KiB
C#
using Microsoft.Data.SqlClient;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using MP.Data.DatabaseModels;
|
|
using MP.Data.DTO;
|
|
using MP.Data.Objects;
|
|
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using static EgwCoreLib.Utils.DtUtils;
|
|
|
|
namespace MP.Data.Controllers
|
|
{
|
|
public class MpSpecController : IDisposable
|
|
{
|
|
#region Public Constructors
|
|
|
|
public MpSpecController(IConfiguration configuration)
|
|
{
|
|
_configuration = configuration;
|
|
Log.Info("Avviata classe MpSpecController");
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Elenco Gruppi tipo Azienda
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AnagGruppi> AnagGruppiAziende()
|
|
{
|
|
return AnagGruppiGetTipo("AZIENDA");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Gruppi tipo Fasi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AnagGruppi> AnagGruppiFase()
|
|
{
|
|
return AnagGruppiGetTipo("FASE");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Gruppi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AnagGruppi> AnagGruppiGetAll()
|
|
{
|
|
List<AnagGruppi> dbResult = new List<AnagGruppi>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetAnagGruppi
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.CodGruppo)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gruppi x tipo
|
|
/// </summary>
|
|
/// <param name="tipoGruppo"></param>
|
|
/// <returns></returns>
|
|
public List<AnagGruppi> AnagGruppiGetTipo(string tipoGruppo)
|
|
{
|
|
List<AnagGruppi> dbResult = new List<AnagGruppi>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetAnagGruppi
|
|
.Where(x => x.TipoGruppo == tipoGruppo)
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.CodGruppo)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Gruppi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AnagKeyValueModel> AnagKeyValGetAll()
|
|
{
|
|
List<AnagKeyValueModel> dbResult = new List<AnagKeyValueModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetAKV
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.nomeVar)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco valori ammessi x Stati commessa (es Yacht Baglietto)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ListValues> AnagStatiComm()
|
|
{
|
|
return ListValuesFilt("PODL", "StatoComm");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco valori ammessi x Tipo articoli
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ListValues> AnagTipoArtLV()
|
|
{
|
|
return ListValuesFilt("AnagArticoli", "Tipo");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco codice articoli che abbiano dati Dossier
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<string> ArticleWithDossier()
|
|
{
|
|
List<string> dbResult = new List<string>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetDossiers
|
|
.AsNoTracking()
|
|
.Select(i => i.CodArticolo)
|
|
.Distinct()
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione Record
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> ArticoliDeleteRecord(AnagArticoli currRec)
|
|
{
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currVal = dbCtx
|
|
.DbSetArticoli
|
|
.Where(x => x.CodArticolo == currRec.CodArticolo)
|
|
.FirstOrDefault();
|
|
dbCtx
|
|
.DbSetArticoli
|
|
.Remove(currVal);
|
|
await dbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante ArticoliDeleteRecord{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco tabella Articoli da filtro
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<AnagArticoli> ArticoliGetSearch(int numRecord, string searchVal = "")
|
|
{
|
|
List<AnagArticoli> dbResult = new List<AnagArticoli>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetArticoli
|
|
.AsNoTracking()
|
|
.Where(x => x.CodArticolo.Contains(searchVal) || x.DescArticolo.Contains(searchVal) || x.Disegno.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
|
|
.OrderBy(x => x.CodArticolo)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco tabella Articoli da filtro
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <param name="azienda"></param>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<AnagArticoli> ArticoliGetSearch(int numRecord, string azienda = "*", string searchVal = "")
|
|
{
|
|
List<AnagArticoli> dbResult = new List<AnagArticoli>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetArticoli
|
|
.AsNoTracking()
|
|
.Where(x => (azienda == "*" || x.Azienda == azienda) && (string.IsNullOrEmpty(searchVal) || x.CodArticolo.Contains(searchVal) || x.DescArticolo.Contains(searchVal) || x.Disegno.Contains(searchVal)))
|
|
.OrderBy(x => x.CodArticolo)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco tabella Articoli IMPIEGATI (da stored stp_ART_getUsed)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<AnagArticoli> ArticoliGetUsed()
|
|
{
|
|
List<AnagArticoli> dbResult = new List<AnagArticoli>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetArticoli
|
|
.FromSqlRaw("EXEC stp_ART_getUsed")
|
|
.AsNoTracking()
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update Record
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> ArticoliUpdateRecord(AnagArticoli editRec)
|
|
{
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currRec = dbCtx
|
|
.DbSetArticoli
|
|
.Where(x => x.CodArticolo == editRec.CodArticolo)
|
|
.FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
currRec.Disegno = editRec.Disegno;
|
|
currRec.DescArticolo = editRec.DescArticolo;
|
|
currRec.Tipo = editRec.Tipo;
|
|
currRec.Azienda = editRec.Azienda;
|
|
dbCtx.Entry(currRec).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetArticoli
|
|
.Add(editRec);
|
|
}
|
|
await dbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante ArticoliUpdateRecord{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco da tabella Config
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ConfigModel> ConfigGetAll()
|
|
{
|
|
List<ConfigModel> dbResult = new List<ConfigModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetConfig
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.Chiave)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update record config
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool ConfigUpdate(ConfigModel updRec)
|
|
{
|
|
bool fatto = false;
|
|
ConfigModel dbResult = new ConfigModel();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetConfig
|
|
.Where(x => x.Chiave == updRec.Chiave)
|
|
.FirstOrDefault();
|
|
if (dbResult != null)
|
|
{
|
|
dbResult.Valore = updRec.Valore;
|
|
dbCtx.SaveChanges();
|
|
fatto = true;
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Intera tab dati macchina
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<DatiMacchineModel> DatiMacchineGetAll()
|
|
{
|
|
List<DatiMacchineModel> dbResult = new List<DatiMacchineModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetDatiMacchine
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.IdxMacchina)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_configuration = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione di un dossier
|
|
/// </summary>
|
|
/// <param name="currRec">record dossier da eliminare</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DossiersDeleteRecord(DossierModel currRec)
|
|
{
|
|
bool answ = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currVal = dbCtx
|
|
.DbSetDossiers
|
|
.Where(x => x.IdxDossier == currRec.IdxDossier)
|
|
.FirstOrDefault();
|
|
dbCtx
|
|
.DbSetDossiers
|
|
.Remove(currVal);
|
|
await dbCtx.SaveChangesAsync();
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante DossiersDeleteRecord{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi n record DOssiers (che contengono ad esempio "salvataggi" di FLuxLog) dato
|
|
/// macchina (ordinato x data registrazione)
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">* = tutte, altrimenti solo x una data macchina</param>
|
|
/// <param name="CodArticolo">* = tutti, altrimenti solo x un dato articolo</param>
|
|
/// <param name="DtStart">Data minima per estrazione records</param>
|
|
/// <param name="DtEnd">Data Massima per estrazione records</param>
|
|
/// <returns></returns>
|
|
public List<DossierModel> DossiersGetLastFilt(string IdxMacchina, string CodArticolo, DateTime DtStart, DateTime DtEnd)
|
|
{
|
|
List<DossierModel> dbResult = new List<DossierModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetDossiers
|
|
.AsNoTracking()
|
|
.Where(x => (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina) && (CodArticolo == "*" || x.CodArticolo == CodArticolo) && (x.DtRif >= DtStart && x.DtRif <= DtEnd))
|
|
.Include(m => m.MachineNav)
|
|
.Include(a => a.ArticoloNav)
|
|
////.Include(o => o.OdlNav)
|
|
.OrderByDescending(x => x.DtRif)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// insert di un record Dossier
|
|
/// </summary>
|
|
/// <param name="editRec">record dossier da modificare</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DossiersInsert(DossierModel newRec)
|
|
{
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetDossiers
|
|
.Add(newRec);
|
|
await dbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante DossiersInsert{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua salvataggio snapshot parametri (con stored) + svuota eventuale cache redis
|
|
/// </summary>
|
|
/// <param name="idxMacchina">macchina</param>
|
|
/// <param name="maxSec">Num massimo secondi per recuperare dati correnti</param>
|
|
/// <param name="dtRif">DataOra riferimento x cui prendere valori antecedenti</param>
|
|
public bool DossiersTakeParamsSnapshot(string idxMacchina, int maxSec, DateTime dtRif)
|
|
{
|
|
bool answ = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
|
|
var pMaxSec = new SqlParameter("@MaxSec", maxSec);
|
|
var pDtRif = new SqlParameter("@DtRif", dtRif);
|
|
|
|
var dbResult = dbCtx
|
|
.Database
|
|
.ExecuteSqlRaw("EXEC stp_FL_TakeSnapshot @IdxMacchina,@MaxSec,@DtRif", pIdxMacchina, pMaxSec, pDtRif);
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua salvataggio snapshot parametri (con stored) + svuota eventuale cache redis
|
|
/// </summary>
|
|
/// <param name="idxMacchina">macchina</param>
|
|
/// <param name="dtMin">Data min x selezione</param>
|
|
/// <param name="dtMax">Data MAX x selezione</param>
|
|
public bool DossiersTakeParamsSnapshotLast(string idxMacchina, DateTime dtMin, DateTime dtMax)
|
|
{
|
|
bool answ = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
|
|
var pDtMin = new SqlParameter("@DtMin", dtMin);
|
|
var pDtMax = new SqlParameter("@DtMax", dtMax);
|
|
|
|
var dbResult = dbCtx
|
|
.Database
|
|
.ExecuteSqlRaw("EXEC stp_FL_TakeSnapshotLast @IdxMacchina,@DtMin,@DtMax", pIdxMacchina, pDtMin, pDtMax);
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update del campo VALORE di un dossier (che contiene json flux log serializzati)
|
|
/// </summary>
|
|
/// <param name="editRec">record dossier da modificare</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DossiersUpdateValore(DossierModel editRec)
|
|
{
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currRec = dbCtx
|
|
.DbSetDossiers
|
|
.Where(x => x.IdxDossier == editRec.IdxDossier)
|
|
.FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
currRec.Valore = editRec.Valore;
|
|
dbCtx.Entry(currRec).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetDossiers
|
|
.Add(editRec);
|
|
}
|
|
await dbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante DossiersUpdateRecord{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco valori link (x home e navMenu laterale)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<LinkMenu> ElencoLink()
|
|
{
|
|
return ListLinkFilt("SpecLink");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunta record EventList
|
|
/// </summary>
|
|
/// <param name="newRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> EvListInsert(EventListModel newRec)
|
|
{
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currRec = dbCtx
|
|
.DbSetEvList
|
|
.Add(newRec);
|
|
await dbCtx.SaveChangesAsync();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante EvListInsert{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Funzione di Data Reduction x FluxLog
|
|
/// </summary>
|
|
/// <param name="idxMaccSel"></param>
|
|
/// <param name="fluxList"></param>
|
|
/// <param name="currPeriodo"></param>
|
|
/// <param name="valMode"></param>
|
|
/// <param name="intReq"></param>
|
|
/// <returns>
|
|
/// Restitusice list dei record statistiche raccolti (da integrare a quelli rpesenti in Redis...)
|
|
/// </returns>
|
|
public async Task<List<StatDedupDTO>> FluxLogDataRedux(string idxMaccSel, List<string> fluxList, Periodo currPeriodo, Enums.ValSelection valMode, Enums.DataInterval intReq, int maxItem)
|
|
{
|
|
List<StatDedupDTO> procStats = new List<StatDedupDTO>();
|
|
Log.Info($"Inizio FluxLogDataRedux | idxMaccSel: {idxMaccSel} | periodo: {currPeriodo.Inizio:yyyy-MM-dd} --> {currPeriodo.Fine:yyyy-MM-dd}");
|
|
TimeSpan step = TimeSpan.FromHours(1);
|
|
switch (intReq)
|
|
{
|
|
case Enums.DataInterval.minute:
|
|
step = TimeSpan.FromMinutes(1.00 / maxItem);
|
|
break;
|
|
|
|
case Enums.DataInterval.hour:
|
|
step = TimeSpan.FromHours(1.00 / maxItem);
|
|
break;
|
|
|
|
case Enums.DataInterval.day:
|
|
step = TimeSpan.FromDays(1.00 / maxItem);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// setup parametri costanti x stored
|
|
var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMaccSel);
|
|
var pOnlyTest = new SqlParameter("@OnlyTest", false);
|
|
|
|
// processo 1:1 ogni flusso
|
|
foreach (var item in fluxList)
|
|
{
|
|
Log.Info($"FluxLogDataRedux | Flux: {item}");
|
|
int numRecProc = 0;
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
// parametri x flusso
|
|
var pCodFlux = new SqlParameter("@CodFlux", item);
|
|
// inizializzo cursore timer
|
|
DateTime dtCursStart = currPeriodo.Inizio;
|
|
DateTime dtCursEnd = dtCursStart.Add(step);
|
|
bool setCompleted = false;
|
|
// dbContext x ogni singolo flusso
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
// opzionalmente timeout comandi a 2 minuti... NON usato x ora e da testare
|
|
//dbCtx.Database.SetCommandTimeout(TimeSpan.FromMinutes(2));
|
|
// li processo per intervallo richiesto, cercando dati nel periodo e
|
|
// selezionando VC
|
|
while (!setCompleted)
|
|
{
|
|
// ora recupero TUTTI i dati della macchina
|
|
var currFlux = await dbCtx
|
|
.DbSetFluxLog
|
|
.Where(x => (x.CodFlux == item) && (x.dtEvento >= dtCursStart && x.dtEvento < dtCursEnd) && (x.IdxMacchina == idxMaccSel))
|
|
.ToListAsync();
|
|
|
|
int numRec = currFlux.Count;
|
|
numRecProc += numRec;
|
|
if (numRec > maxItem)
|
|
{
|
|
List<Periodo> listPeriodi = new List<Periodo>();
|
|
|
|
switch (valMode)
|
|
{
|
|
case Enums.ValSelection.First:
|
|
// recupero 2° item
|
|
var recStart = currFlux.Skip(1).FirstOrDefault();
|
|
// salvo periodo!
|
|
listPeriodi.Add(new Periodo(recStart.dtEvento, dtCursEnd));
|
|
break;
|
|
|
|
case Enums.ValSelection.Last:
|
|
// recupero ultimo item
|
|
var recEnd = currFlux.LastOrDefault();
|
|
// salvo periodo!
|
|
listPeriodi.Add(new Periodo(dtCursStart, recEnd.dtEvento));
|
|
break;
|
|
|
|
case Enums.ValSelection.Center:
|
|
int idx = 1;
|
|
// per iniziare mi metto a 1/(n+1) rec come step
|
|
var recCent = currFlux.Skip(idx / (maxItem + 1)).FirstOrDefault();
|
|
listPeriodi.Add(new Periodo(dtCursStart, recCent.dtEvento));
|
|
// salvo restanti periodi (se > 1)!
|
|
if (maxItem > 1)
|
|
{
|
|
for (int i = 2; i < maxItem; i++)
|
|
{
|
|
DateTime dtInizio = recCent.dtEvento;
|
|
recCent = currFlux.Skip(i / (maxItem + 1)).FirstOrDefault();
|
|
listPeriodi.Add(new Periodo(dtInizio, recCent.dtEvento));
|
|
}
|
|
}
|
|
// aggiungo ultimo...
|
|
listPeriodi.Add(new Periodo(recCent.dtEvento.AddSeconds(1), dtCursEnd));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// ciclo x tutti i periodi e chiamo stored...
|
|
foreach (var slot in listPeriodi)
|
|
{
|
|
// parametri x periodo (base)
|
|
var pDtStart = new SqlParameter("@DtStart", slot.Inizio);
|
|
var pDtEnd = new SqlParameter("@DtEnd", slot.Fine);
|
|
var dbResult = dbCtx
|
|
.Database
|
|
.ExecuteSqlRaw("EXEC man.stp_ReduceFluxLog @IdxMacchina, @CodFlux, @DtStart, @DtEnd, @OnlyTest", pIdxMacchina, pCodFlux, pDtStart, pDtEnd, pOnlyTest);
|
|
}
|
|
}
|
|
|
|
// incremento dt fine periodo
|
|
dtCursStart = dtCursEnd;
|
|
dtCursEnd = dtCursStart.Add(step);
|
|
setCompleted = dtCursStart >= currPeriodo.Fine;
|
|
}
|
|
}
|
|
// fermo cronometro e salvo su DB...
|
|
sw.Stop();
|
|
StatDedupDTO currStat = new StatDedupDTO()
|
|
{
|
|
IdxMacchina = idxMaccSel,
|
|
CodFlux = item,
|
|
Interval = intReq,
|
|
Num4Int = maxItem,
|
|
NumRec = numRecProc,
|
|
ProcTime = sw.Elapsed.TotalSeconds
|
|
};
|
|
procStats.Add(currStat);
|
|
}
|
|
Log.Info($"FINE FluxLogDataRedux | idxMaccSel: {idxMaccSel} | periodo: {currPeriodo.Inizio:yyyy-MM-dd} --> {currPeriodo.Fine:yyyy-MM-dd}");
|
|
return procStats;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi n record flux log dato macchina e flusso (ordinato x data registrazione)
|
|
/// </summary>
|
|
/// <param name="DtMax">Data massima x eventi</param>
|
|
/// <param name="DtMin">Data minima x eventi</param>
|
|
/// <param name="IdxMacchina">* = tutte, altrimenti solo x una data macchina</param>
|
|
/// <param name="CodFlux">*=tutti, altrimenti solo selezionato</param>
|
|
/// <param name="MaxRec">numero massimo record da restituire</param>
|
|
/// <returns></returns>
|
|
public List<FluxLog> FluxLogGetLastFilt(DateTime DtMax, DateTime DtMin, string IdxMacchina, string CodFlux, int MaxRec)
|
|
{
|
|
List<FluxLog> dbResult = new List<FluxLog>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetFluxLog
|
|
.AsNoTracking()
|
|
.Where(x => (x.dtEvento >= DtMin && x.dtEvento <= DtMax) && (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina) && (CodFlux == "*" || x.CodFlux == CodFlux))
|
|
.OrderByDescending(x => x.dtEvento)
|
|
.Take(MaxRec)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Gruppi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ParetoFluxLogDTO> FluxLogPareto(string idxMacchina, DateTime dtFrom, DateTime dtTo)
|
|
{
|
|
List<ParetoFluxLogDTO> dbResult = new List<ParetoFluxLogDTO>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetFluxLog
|
|
.Where(x => (string.IsNullOrEmpty(idxMacchina) || x.IdxMacchina == idxMacchina) && (dtFrom <= x.dtEvento && x.dtEvento <= dtTo))
|
|
.AsNoTracking()
|
|
.GroupBy(x => x.CodFlux)
|
|
.Select(g => new ParetoFluxLogDTO() { IdxMacchina = idxMacchina, CodFlux = g.Key, Qty = g.Count() })
|
|
.OrderByDescending(x => x.Qty)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stored manutenzione del DB
|
|
/// </summary>
|
|
/// <param name="doExec">Esegue realmente il task</param>
|
|
/// <param name="doUpdStat">Aggiornamento statistiche</param>
|
|
/// <param name="doSave">Salvataggio</param>
|
|
/// <param name="minPgCnt">def: 1000</param>
|
|
/// <param name="minAvgFrag">def: 10</param>
|
|
/// <param name="maxAvgFragReb">def: 50</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> ForceDbMaint(bool doExec, bool doUpdStat, bool doSave, int minPgCnt, int minAvgFrag, int maxAvgFragReb)
|
|
{
|
|
Log.Info($"Inizio ForceDbMaint on MoonProAdminContext");
|
|
bool fatto = false;
|
|
// uso context admin x query lunghe
|
|
using (var dbCtx = new MoonProAdminContext(_configuration))
|
|
{
|
|
var pFlgExec = new SqlParameter("@FlgExec", doExec ? "Y" : "N");
|
|
var pFlgUpdStat = new SqlParameter("@FlgUpdStat", doUpdStat ? "Y" : "N");
|
|
var pFlgSave = new SqlParameter("@FlgSave", doSave ? "Y" : "N");
|
|
var pMinPgCnt = new SqlParameter("@min_page_count", minPgCnt);
|
|
var pMinAvgFrag = new SqlParameter("@min_avg_fragmentation_in_percent", minAvgFrag);
|
|
var pMaxAvgFrag = new SqlParameter("@max_avg_fragmentation_per_rebuild", maxAvgFragReb);
|
|
|
|
var dbResult = await dbCtx
|
|
.Database
|
|
.ExecuteSqlRawAsync("EXEC man.stp_Utility_Maintanance");
|
|
//.ExecuteSqlRaw("EXEC man.stp_Utility_Maintanance @FlgExec, @FlgUpdStat, @FlgSave, @min_page_count, @min_avg_fragmentation_in_percent, @max_avg_fragmentation_per_rebuild", pFlgExec, pFlgUpdStat, pFlgSave, pMinPgCnt, pMinAvgFrag, pMaxAvgFrag);
|
|
fatto = true;
|
|
}
|
|
Log.Info($"FINE ForceDbMaint on MoonProAdminContext");
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco giacenze
|
|
/// </summary>
|
|
/// <param name="IdxOdl">id odl da cercare</param>
|
|
/// <returns></returns>
|
|
public List<AnagGiacenzeModel> ListGiacenze(int IdxOdl)
|
|
{
|
|
List<AnagGiacenzeModel> dbResult = new List<AnagGiacenzeModel>();
|
|
using (var dbCtx = new MoonPro_InveContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbResult = dbCtx
|
|
.DbGiacenzeData
|
|
.AsNoTracking()
|
|
.Where(x => x.IdxOdl == IdxOdl)
|
|
.ToList();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante ListGiacenze{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco link JQM completo
|
|
/// </summary>
|
|
/// <param name="tipoLink"></param>
|
|
/// <returns></returns>
|
|
public List<LinkMenu> ListLinkAll()
|
|
{
|
|
List<LinkMenu> dbResult = new List<LinkMenu>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetLinkMenu
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.ordine)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco link JQM dato filtro tipo
|
|
/// </summary>
|
|
/// <param name="tipoLink"></param>
|
|
/// <returns></returns>
|
|
public List<LinkMenu> ListLinkFilt(string tipoLink)
|
|
{
|
|
List<LinkMenu> dbResult = new List<LinkMenu>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetLinkMenu
|
|
.Where(x => x.TipoLink == tipoLink)
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.ordine)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ODL filtrati x stato, articolo, KeyRich (che contiene stato)
|
|
/// </summary>
|
|
/// <param name="inCorso">Stato ODL: true=in corso/completato</param>
|
|
/// <param name="codArt">Cod articolo</param>
|
|
/// <param name="keyRichPart">KeyRich (parziale) da cercare (es cod stato x yacht)</param>
|
|
/// <param name="Reparto">Reparto selezionato</param>
|
|
/// <param name="IdxMacchina">Macchina selezionata</param>
|
|
/// <param name="startDate">Data inizio</param>
|
|
/// <param name="endDate">Data fine</param>
|
|
/// <returns></returns>
|
|
public List<ODLExpModel> ListODLFilt(bool inCorso, string codArt, string keyRichPart, string Reparto, string IdxMacchina, DateTime startDate, DateTime endDate)
|
|
{
|
|
List<ODLExpModel> dbResult = new List<ODLExpModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var InCorso = new SqlParameter("@InCorso", inCorso);
|
|
var CodArt = new SqlParameter("@CodArt", codArt);
|
|
var KeyRich = new SqlParameter("@KeyRich", keyRichPart);
|
|
var CodGruppo = new SqlParameter("@CodGruppo", Reparto);
|
|
var IdxMacc = new SqlParameter("@IdxMacchina", IdxMacchina);
|
|
var DataFrom = new SqlParameter("@DataFrom", startDate);
|
|
var DataTo = new SqlParameter("@DataTo", endDate);
|
|
|
|
dbResult = dbCtx
|
|
.DbSetODLExp
|
|
.FromSqlRaw("EXEC stp_ODL_getByFiltSpec @InCorso, @CodArt, @KeyRich, @CodGruppo, @IdxMacchina, @DataFrom, @DataTo", InCorso, CodArt, KeyRich, CodGruppo, IdxMacc, DataFrom, DataTo)
|
|
.AsNoTracking()
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco PODL non avviati filtrati x articolo, KeyRich (che contiene stato)
|
|
/// </summary>
|
|
/// <param name="lanciato">Solo lanciati (1) o ancora disponibili (0)</param>
|
|
/// <param name="keyRichPart">KeyRich (parziale) da cercare (es cod stato x yacht)</param>
|
|
/// <param name="idxMacchina">Macchina</param>
|
|
/// <param name="codGruppo">Gruppo</param>
|
|
/// <returns></returns>
|
|
public List<PODLExpModel> ListPODLFilt(bool lanciato, string keyRichPart, string idxMacchina, string codGruppo, DateTime startDate, DateTime endDate)
|
|
{
|
|
List<PODLExpModel> dbResult = new List<PODLExpModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var Lanc = new SqlParameter("@Lanciato", lanciato);
|
|
var KeyRich = new SqlParameter("@KeyRich", keyRichPart);
|
|
var CodGrp = new SqlParameter("@CodGruppo", codGruppo);
|
|
var IdxMacc = new SqlParameter("@IdxMacchina", idxMacchina);
|
|
var DateFrom = new SqlParameter("@DtInizio", startDate);
|
|
var DateTo = new SqlParameter("@DtFine", endDate);
|
|
|
|
dbResult = dbCtx
|
|
.DbSetPODLExp
|
|
.FromSqlRaw("EXEC stp_PODL_getByFiltSpec @Lanciato, @KeyRich, @CodGruppo, @IdxMacchina, @DtInizio, @DtFine", Lanc, KeyRich, CodGrp, IdxMacc, DateFrom, DateTo)
|
|
.AsNoTracking()
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco valori ammessi x tabella/colonna
|
|
/// </summary>
|
|
/// <param name="tabName"></param>
|
|
/// <param name="fieldName"></param>
|
|
/// <returns></returns>
|
|
public List<ListValues> ListValuesFilt(string tabName, string fieldName)
|
|
{
|
|
List<ListValues> dbResult = new List<ListValues>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetListValues
|
|
.Where(x => x.TableName == tabName && x.FieldName == fieldName)
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.ordinal)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Macchine dato operatore secondo gruppi (macchine/operatore)
|
|
/// </summary>
|
|
/// <param name="MatrOpr"></param>
|
|
/// <returns></returns>
|
|
public List<Macchine> MacchineByMatrOper(int MatrOpr)
|
|
{
|
|
List<Macchine> dbResult = new List<Macchine>();
|
|
try
|
|
{
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
if (MatrOpr == 0)
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMacchine
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.IdxMacchina)
|
|
.ToList();
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetGrp2Oper
|
|
.Where(g => g.MatrOpr == MatrOpr)
|
|
.Join(dbCtx.DbSetGrp2Macc,
|
|
g => g.CodGruppo,
|
|
m => m.CodGruppo,
|
|
(g, m) => m
|
|
)
|
|
.Distinct()
|
|
.Join(dbCtx.DbSetMacchine,
|
|
g => g.IdxMacchina,
|
|
m => m.IdxMacchina,
|
|
(g, m) => m
|
|
)
|
|
.Distinct()
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.IdxMacchina)
|
|
.ToList();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in MacchineByMatrOper{Environment.NewLine}{exc}");
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco da tabella Macchine
|
|
/// </summary>
|
|
/// <param name="codGruppo"></param>
|
|
/// <returns></returns>
|
|
public List<Macchine> MacchineGetFilt(string codGruppo)
|
|
{
|
|
List<Macchine> dbResult = new List<Macchine>();
|
|
try
|
|
{
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
if (codGruppo == "*")
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetMacchine
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.IdxMacchina)
|
|
.ToList();
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetGrp2Macc
|
|
.Where(g => g.CodGruppo == codGruppo)
|
|
.Join(dbCtx.DbSetMacchine,
|
|
g => g.IdxMacchina,
|
|
m => m.IdxMacchina,
|
|
(g, m) => m
|
|
)
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.IdxMacchina)
|
|
.ToList();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in MacchineGetFilt{Environment.NewLine}{exc}");
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco id Macchine che abbiano dati FLuxLog, nel periodo indicato
|
|
/// </summary>
|
|
/// <param name="dtStart"></param>
|
|
/// <param name="dtEnd"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<string>> MacchineWithFlux(DateTime dtStart, DateTime dtEnd)
|
|
{
|
|
List<string> dbResult = new List<string>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = await dbCtx
|
|
.DbSetFluxLog
|
|
.AsNoTracking()
|
|
.Where(x => x.dtEvento >= dtStart && x.dtEvento <= dtEnd)
|
|
.Select(i => i.IdxMacchina)
|
|
.Distinct()
|
|
.ToListAsync();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco da tabella MappaStatoExpl
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<MappaStatoExpl> MseGetAll(int maxAge = 2000)
|
|
{
|
|
List<MappaStatoExpl> dbResult = new List<MappaStatoExpl>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var maxAgeSec = new SqlParameter("@maxAgeSec", maxAge);
|
|
|
|
dbResult = dbCtx
|
|
.DbSetMSE
|
|
.FromSqlRaw("EXEC stp_MSE_getData @maxAgeSec", maxAgeSec)
|
|
.AsNoTracking()
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ODL dato batch selezionato
|
|
/// </summary>
|
|
/// <param name="BatchSel">Batch richiesto</param>
|
|
/// <returns></returns>
|
|
public List<int> OdlByBatch(string batchSel)
|
|
{
|
|
List<int> dbResult = new List<int>();
|
|
using (var dbCtx = new MoonPro_InveContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbResult = dbCtx
|
|
.DbGiacenzeData
|
|
.AsNoTracking()
|
|
.Where(x => x.IdentRG == batchSel)
|
|
.Select(x => x.IdxOdl)
|
|
.ToList();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante OdlByBatch{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// ODL da chiave
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public ODLExpModel OdlByKey(int IdxOdl)
|
|
{
|
|
ODLExpModel dbResult = new ODLExpModel();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetODLExp
|
|
.AsNoTracking()
|
|
.Where(x => x.IdxOdl == IdxOdl)
|
|
.FirstOrDefault();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante OdlByKey{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiusura ODL con eventuale conferma pezzi
|
|
/// </summary>
|
|
/// <param name="idxOdl">idx odl da chiudere</param>
|
|
/// <param name="idxMacchina">idx macchina</param>
|
|
/// <param name="matrOpr">matricola operatore</param>
|
|
/// <param name="confPezzi">indica se confermare i pezzi prima di chiudere ODL</param>
|
|
/// <param name="confRett">Conferma con rettifica (ev 121) x pezzi lasciati in macchina</param>
|
|
/// <param name="modoConfProd">Modo conferma produzione (0=periodo, 1=giorno, 2=turno)</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> ODLClose(int idxOdl, string idxMacchina, int matrOpr, bool confPezzi, bool confRett, int modoConfProd)
|
|
{
|
|
bool fatto = false;
|
|
await Task.Delay(1);
|
|
if (idxOdl > 0)
|
|
{
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
// preparo i parametri
|
|
var IdxODL = new SqlParameter("@IdxODL", idxOdl);
|
|
var IdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
|
|
|
|
// FARE FIXME TODO !!! da valutare casi setup/autoconferma...
|
|
#if false
|
|
// controllo se HO pezzi da confermare...
|
|
var statoProd = StatoProdMacchina(idxMacchina);
|
|
if (statoProd.pezziNonConfermati < 1)
|
|
{ }
|
|
#endif
|
|
|
|
// se richiesto confermo produzione
|
|
if (confPezzi)
|
|
{
|
|
var MatrApp = new SqlParameter("@MatrApp", idxMacchina);
|
|
|
|
/* ----------------------------------
|
|
* CONFERMA PEZZI
|
|
*
|
|
* condizioni da verificare:
|
|
* - gestione rettifica (ev121) / pezzi da LASCIARE in macchina
|
|
* - conferma a zero pezzi (setup) oppure con i pezzi fatti e non ancora confermati
|
|
*
|
|
*
|
|
*
|
|
* */
|
|
|
|
// recupero i dati dei pezzi da confermare... con DbSetPzProd + exec
|
|
// stp_PzProd_getByMacchina 'SIMUL_01'
|
|
|
|
// stp_ConfermaProduzCompletaFull
|
|
/*
|
|
* @idxMacchina NVARCHAR(50),
|
|
@MatrApp INT,
|
|
@dataFrom DATETIME,
|
|
@dataTo DATETIME,
|
|
@pezziConf INT,
|
|
@pezziLasciati INT, -- pezzi lasciati = evento 121 (-) pre conferma e (+) dopo --> da lasciare in macchina post conferma
|
|
@pezziScar INT = 0, -- pezzi scartati (registrati da 2016.11.20) DA INDICARE COME VALORE > 0!!! sennò faccio ABS...
|
|
@TipoConf INT = 0, -- Tipo intervallo conferma: 0 = periodo intero, 1 = per giorni, 2 = per turni
|
|
@DataOraApp DATETIME = NULL, -- di norma GETDATE() nel programma - serve per ricalcolo
|
|
@TestConferma BIT = 1 -- TestConferma : 1 = verifica conf. duplicata e inserisci in ElencoConfermeProd, 0 = nessuna verifica e inserimento ( per ricalcolo )
|
|
*/
|
|
}
|
|
|
|
// ora chiudo ODL con stored SENZA ritorno...
|
|
try
|
|
{
|
|
var dbResult = dbCtx
|
|
.Database
|
|
.ExecuteSqlRaw("EXEC stp_ODL_fineProd @IdxODL, @IdxMacchina", IdxODL, IdxMacchina);
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante ODLClose{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero odl data chiave
|
|
/// </summary>
|
|
/// <param name="idxOdl"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public ODLModel OdlGetByKey(int idxOdl)
|
|
{
|
|
ODLModel dbResult = new ODLModel();
|
|
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetODL
|
|
.FirstOrDefault(x => x.IdxOdl == idxOdl);
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero Odl CORRENTI
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ODLModel> OdlGetCurrent()
|
|
{
|
|
List<ODLModel> dbResult = new List<ODLModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetODL
|
|
.Where(x => x.DataInizio != null && x.DataFine == null)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco TUTTI GLI ODL
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ODLModel> OdlListAll()
|
|
{
|
|
List<ODLModel> dbResult = new List<ODLModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetODL
|
|
.AsNoTracking()
|
|
.ToList();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante ListOdlAll{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Statistiche ODL calcolate (da stored stp_STAT_ODL)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<StatODLModel>> OdlStart(int IdxOdl)
|
|
{
|
|
List<StatODLModel> dbResult = new List<StatODLModel>();
|
|
if (IdxOdl > 0)
|
|
{
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var IdxODL = new SqlParameter("@IdxODL", IdxOdl);
|
|
|
|
dbResult = await dbCtx
|
|
.DbSetStatOdl
|
|
.FromSqlRaw("EXEC stp_STAT_ODL @IdxODL", IdxODL)
|
|
.AsNoTracking()
|
|
.ToListAsync();
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco parametri validi x una data macchina
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <returns></returns>
|
|
public List<string> ParametriGetFilt(string IdxMacchina)
|
|
{
|
|
List<string> dbResult = new List<string>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetFluxLog
|
|
.AsNoTracking()
|
|
.Where(x => (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina))
|
|
.Take(1000)
|
|
.Select(i => i.CodFlux)
|
|
.Distinct()
|
|
.OrderBy(x => x)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stato prod macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public PzProdModel PezziProdMacchina(string idxMacchina)
|
|
{
|
|
PzProdModel dbResult = new PzProdModel();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
var IdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
|
|
dbResult = dbCtx
|
|
.DbSetPzProd
|
|
.FromSqlRaw("EXEC stp_PzProd_getByMacchina @IdxMacchina", IdxMacchina)
|
|
.AsNoTracking()
|
|
.FirstOrDefault();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero PODL da chiave
|
|
/// </summary>
|
|
/// <param name="idxPODL"></param>
|
|
/// <returns></returns>
|
|
public async Task<PODLModel> PODL_getByKey(int idxPODL)
|
|
{
|
|
PODLModel dbResult = new PODLModel();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetPODL
|
|
.AsNoTracking()
|
|
.Where(x => x.IdxPromessa == idxPODL)
|
|
.Include(a => a.ArticoloNav)
|
|
.FirstOrDefault();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante PODL_getByKey{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero PODL da IdxOdl
|
|
/// </summary>
|
|
/// <param name="idxPODL"></param>
|
|
/// <returns></returns>
|
|
public PODLModel PODL_getByOdl(int idxODL)
|
|
{
|
|
PODLModel dbResult = new PODLModel();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetPODL
|
|
.AsNoTracking()
|
|
.Where(x => x.IdxOdl == idxODL)
|
|
.FirstOrDefault();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante PODL_getByOdl{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Avvio setup ODL da PODL
|
|
/// </summary>
|
|
/// <param name="editRec"></param>
|
|
/// <param name="matrOpr"></param>
|
|
/// <param name="tcRich"></param>
|
|
/// <param name="pzPallet"></param>
|
|
/// <param name="note"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PODL_startSetup(PODLExpModel editRec, int matrOpr, double tcRich, int pzPallet, string note, DateTime dtEvent)
|
|
{
|
|
bool answ = false;
|
|
|
|
PODLModel recPODL = new PODLModel()
|
|
{
|
|
IdxPromessa = editRec.IdxPromessa,
|
|
KeyRichiesta = editRec.KeyRichiesta,
|
|
KeyBCode = editRec.KeyBCode,
|
|
IdxOdl = editRec.IdxOdl,
|
|
CodArticolo = editRec.CodArticolo,
|
|
CodGruppo = editRec.CodGruppo,
|
|
IdxMacchina = editRec.IdxMacchina,
|
|
NumPezzi = editRec.NumPezzi,
|
|
Tcassegnato = editRec.Tcassegnato,
|
|
DueDate = editRec.DueDate,
|
|
Priorita = editRec.Priorita,
|
|
PzPallet = editRec.PzPallet,
|
|
Note = editRec.Note,
|
|
CodCli = editRec.CodCli,
|
|
InsertDate = editRec.InsertDate
|
|
};
|
|
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currRec = dbCtx
|
|
.DbSetPODL
|
|
.AsNoTracking()
|
|
.Where(x => x.IdxPromessa == recPODL.IdxPromessa)
|
|
.FirstOrDefault();
|
|
|
|
if (currRec != null)
|
|
{
|
|
// eseguo stored attrezzaggio
|
|
var IdxPromessa = new SqlParameter("@idxPromessa", recPODL.IdxPromessa);
|
|
var MatrOpr = new SqlParameter("@MatrOpr", matrOpr);
|
|
var IdxMacchina = new SqlParameter("@IdxMacchina", recPODL.IdxMacchina);
|
|
var TCRichAttr = new SqlParameter("@TCRichAttr", tcRich);
|
|
var PzPallet = new SqlParameter("@PzPallet", pzPallet);
|
|
var Note = new SqlParameter("@Note", note);
|
|
var DtEvento = new SqlParameter("@dtEvento", dtEvent);
|
|
var callResult = await dbCtx
|
|
.Database
|
|
.ExecuteSqlRawAsync("EXEC stp_ODL_inizioSetupPromessa @idxPromessa, @MatrOpr, @IdxMacchina, @TCRichAttr, @PzPallet, @Note, @dtEvento", IdxPromessa, MatrOpr, IdxMacchina, TCRichAttr, PzPallet, Note, DtEvento);
|
|
|
|
answ = true;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante PODL_doSetup{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiamata salvataggio ricetta su DB
|
|
/// </summary>
|
|
/// <param name="idxPODL"></param>
|
|
/// <param name="recipeName"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PODL_updateRecipe(int idxPODL, string recipeName)
|
|
{
|
|
bool answ = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currRec = dbCtx
|
|
.DbSetPODL
|
|
.Where(x => x.IdxPromessa == idxPODL)
|
|
.FirstOrDefault();
|
|
|
|
if (currRec != null)
|
|
{
|
|
currRec.Recipe = recipeName;
|
|
dbCtx.Entry(currRec).State = EntityState.Modified;
|
|
await dbCtx.SaveChangesAsync();
|
|
answ = true;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante PODL_updateRecipe{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
await Task.Delay(1);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione Record
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PODLDeleteRecord(PODLExpModel currRec)
|
|
{
|
|
PODLModel recPODL = new PODLModel()
|
|
{
|
|
IdxPromessa = currRec.IdxPromessa,
|
|
KeyRichiesta = currRec.KeyRichiesta,
|
|
KeyBCode = currRec.KeyBCode,
|
|
IdxOdl = currRec.IdxOdl,
|
|
CodArticolo = currRec.CodArticolo,
|
|
CodGruppo = currRec.CodGruppo,
|
|
IdxMacchina = currRec.IdxMacchina,
|
|
NumPezzi = currRec.NumPezzi,
|
|
Tcassegnato = currRec.Tcassegnato,
|
|
DueDate = currRec.DueDate,
|
|
Priorita = currRec.Priorita,
|
|
PzPallet = currRec.PzPallet,
|
|
Note = currRec.Note,
|
|
CodCli = currRec.CodCli,
|
|
InsertDate = currRec.InsertDate
|
|
};
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currVal = dbCtx
|
|
.DbSetPODL
|
|
.Where(x => x.IdxPromessa == recPODL.IdxPromessa)
|
|
.FirstOrDefault();
|
|
dbCtx
|
|
.DbSetPODL
|
|
.Remove(currVal);
|
|
await dbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante PODLDeleteRecord{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update Record
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PODLUpdateRecord(PODLModel editRec)
|
|
{
|
|
bool fatto = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
var currRec = dbCtx
|
|
.DbSetPODL
|
|
.Where(x => x.IdxPromessa == editRec.IdxPromessa)
|
|
.FirstOrDefault();
|
|
if (currRec != null)
|
|
{
|
|
currRec.CodGruppo = editRec.CodGruppo;
|
|
currRec.CodArticolo = editRec.CodArticolo;
|
|
currRec.IdxMacchina = editRec.IdxMacchina;
|
|
currRec.KeyBCode = editRec.KeyBCode;
|
|
currRec.KeyRichiesta = editRec.KeyRichiesta;
|
|
currRec.NumPezzi = editRec.NumPezzi;
|
|
currRec.Tcassegnato = editRec.Tcassegnato;
|
|
currRec.Attivabile = editRec.Attivabile;
|
|
currRec.Note = editRec.Note;
|
|
dbCtx.Entry(currRec).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetPODL
|
|
.Add(editRec);
|
|
}
|
|
await dbCtx.SaveChangesAsync();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione durante PODLUpdateRecord{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Annulla modifiche su una specifica entity (cancel update)
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
public bool RollBackEntity(object item)
|
|
{
|
|
bool answ = false;
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
try
|
|
{
|
|
if (dbCtx.Entry(item).State == Microsoft.EntityFrameworkCore.EntityState.Deleted || dbCtx.Entry(item).State == Microsoft.EntityFrameworkCore.EntityState.Modified)
|
|
{
|
|
dbCtx.Entry(item).Reload();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Vocabolario (completo)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<VocabolarioModel> VocabolarioGetAll()
|
|
{
|
|
List<VocabolarioModel> dbResult = new List<VocabolarioModel>();
|
|
using (var dbCtx = new MoonProContext(_configuration))
|
|
{
|
|
dbResult = dbCtx
|
|
.DbSetVocabolario
|
|
.AsNoTracking()
|
|
.OrderBy(x => x.Lemma)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static IConfiguration _configuration;
|
|
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |