Samuele Locatelli
4956 lines
221 KiB
C#
4956 lines
221 KiB
C#
using MapoSDK;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
using SteamWare;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
|
|
namespace MapoDb
|
|
{
|
|
/// <summary>
|
|
/// classe gestione operazioni su DB tramite MapoDb
|
|
/// </summary>
|
|
public class DataLayer
|
|
{
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// Valori config da tabella corrente
|
|
/// </summary>
|
|
public DS_Utility.ConfigDataTable ListConfig = new DS_Utility.ConfigDataTable();
|
|
|
|
/// <summary>
|
|
/// Oggetto MapoDb impiegato da DataLayer x i suoi accessi ai dati
|
|
/// </summary>
|
|
public MapoDb MapoDbObj = new MapoDb();
|
|
|
|
// Table adapter vari...
|
|
public DS_applicazioneTableAdapters.AnagraficaGruppiTableAdapter taAG;
|
|
|
|
public DS_applicazioneTableAdapters.AlarmLogTableAdapter taAlarmLog;
|
|
public DS_ProdTempiTableAdapters.AnagArticoliTableAdapter taAnagArt;
|
|
public DS_applicazioneTableAdapters.AnagraficaEventiTableAdapter taAnagEventi;
|
|
public DS_applicazioneTableAdapters.AnagraficaStatiTableAdapter taAnagStati;
|
|
public DS_applicazioneTableAdapters.AnagTagsTableAdapter taAnagTags;
|
|
public DS_ArcaTableAdapters.GiacenzeTableAdapter taArcaGiac;
|
|
public DS_IntServTableAdapters.ProduzioneAs400TableAdapter taAs400;
|
|
public DS_ProdTempiTableAdapters.CalendFesteFerieTableAdapter taCalFF;
|
|
public DS_UtilityTableAdapters.CommentiTableAdapter taComm;
|
|
public DS_DossParTableAdapters.ConfFluxTableAdapter taConfFlux;
|
|
public DS_UtilityTableAdapters.ConfigTableAdapter taConfig;
|
|
public DS_ProdTempiTableAdapters.DatiConfermatiTableAdapter taDatiConf;
|
|
public DS_ProdTempiTableAdapters.DatiMacchineTableAdapter taDatiMacchine;
|
|
public DS_ProdTempiTableAdapters.DatiProduzioneTableAdapter taDatiProd;
|
|
public DS_ProdTempiTableAdapters.stp_repDonati_getDatiProdMacchinaTableAdapter taDatiProdMacch;
|
|
public DS_ProdTempiTableAdapters.stp_repDonati_getDatiProdMacchinaPeriodoTableAdapter taDatiProdMacchPer;
|
|
public DS_ProdTempiTableAdapters.stp_repDonati_getLastStatoDurataMacchinaTableAdapter taDatiStatoMacch;
|
|
public DS_applicazioneTableAdapters.DecNumArticoliTableAdapter taDecNA;
|
|
public DS_applicazioneTableAdapters.DiarioDichiarazioniTableAdapter taDiarioDich;
|
|
public DS_DossParTableAdapters.DossiersTableAdapter taDOSS;
|
|
public DS_applicazioneTableAdapters.EventListTableAdapter taEventi;
|
|
public DS_applicazioneTableAdapters.FluxLogTableAdapter taFL;
|
|
public DS_IntServTableAdapters.TransitoDatiTableAdapter taIS_TrDati;
|
|
public DS_IntServTableAdapters.IstanzeKITTableAdapter taIstK;
|
|
public DS_applicazioneTableAdapters.KeepAliveTableAdapter taKeepAlive;
|
|
public DS_UtilityTableAdapters.v_selListValTableAdapter taListVal;
|
|
public DS_ProdTempiTableAdapters.Macchine2SlaveTableAdapter taM2S;
|
|
public DS_applicazioneTableAdapters.MacchineTableAdapter taMacchine;
|
|
public DS_PlanTableAdapters.MachineParamsTableAdapter taMacParams;
|
|
public DS_MAGTableAdapters.ElencoLottiTableAdapter taMagELotti;
|
|
public DS_ProdTempiTableAdapters.MappaStatoExplTableAdapter taMSE;
|
|
public DS_ProdTempiTableAdapters.ODLTableAdapter taODL;
|
|
public DS_applicazioneTableAdapters.AnagraficaOperatoriTableAdapter taOp;
|
|
public DS_applicazioneTableAdapters.AnagraficaOperatori2insTableAdapter taOp2ins;
|
|
public DS_PlanTableAdapters.CalDispTableAdapter taPlanCalDisp;
|
|
public DS_PlanTableAdapters.CalStopTableAdapter taPlanCalStop;
|
|
public DS_PlanTableAdapters.RichiesteTableAdapter taPlanRichieste;
|
|
public DS_ProdTempiTableAdapters.PromesseODLTableAdapter taPODL;
|
|
public DS_ProdTempiTableAdapters.PostazioniMapoTableAdapter taPostazioni;
|
|
public DS_PlanTableAdapters.PromesseINTableAdapter taPromIn;
|
|
public DS_PlanTableAdapters.PromesseOUTTableAdapter taPromOut;
|
|
public DS_ProdTempiTableAdapters.stp_PzProd_getByMacchinaTableAdapter taPzProd2conf;
|
|
public DS_ProdTempiTableAdapters.RegistroControlliTableAdapter taRC;
|
|
public DS_applicazioneTableAdapters.RemoteRebootLogTableAdapter taRemReb;
|
|
public DS_ProdTempiTableAdapters.RegistroScartiTableAdapter taRS;
|
|
public DS_UtilityTableAdapters.v_selArticoliTableAdapter taSelArt;
|
|
public DS_UtilityTableAdapters.v_selMacchineTableAdapter taSelMacc;
|
|
public DS_UtilityTableAdapters.v_selODLTableAdapter taSelOdlFree;
|
|
public DS_applicazioneTableAdapters.SignalLogTableAdapter taSigLog;
|
|
public DS_SheetTechTableAdapters.ST_ActualTableAdapter taSTA;
|
|
public DS_SheetTechTableAdapters.ST_ActualRowTableAdapter taSTAR;
|
|
public DS_applicazioneTableAdapters.DiarioDiBordoTableAdapter taStati;
|
|
public DS_applicazioneTableAdapters.StatoMacchineTableAdapter taStatoMacchine;
|
|
public DS_ProdTempiTableAdapters.StatoProdTableAdapter taStatoProd;
|
|
public DS_SheetTechTableAdapters.ST_CheckTableAdapter taSTChk;
|
|
public DS_ProdTempiTableAdapters.TempiCicloRilevatiTableAdapter taTempiCicloRilevati;
|
|
public DS_ProdTempiTableAdapters.stp_TempoByIdxMaccPeriodClassTableAdapter taTempoByClass;
|
|
public DS_IntServTableAdapters.TKS_SearchTableAdapter taTKS;
|
|
public DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter taTranIngr;
|
|
public DS_ProdTempiTableAdapters.TurniMacchinaTableAdapter taTurniMacc;
|
|
public DS_IntServTableAdapters.WipSetupKitTableAdapter taWKS;
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Init classe
|
|
/// </summary>
|
|
public DataLayer()
|
|
{
|
|
initTA();
|
|
setupConnectionStringBase();
|
|
|
|
// aggiunta x gestione timeout esteso (ove necessario)!
|
|
fixCommandTimeout();
|
|
|
|
// init oggetto MapoDb
|
|
MapoDbObj = new MapoDb();
|
|
|
|
// init config..
|
|
ListConfig = taConfig.GetData();
|
|
|
|
// altri init
|
|
setupConf();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Init class
|
|
/// </summary>
|
|
/// <param name="enableRedisMsg">Abilitazione ch messaggi broadcast redis</param>
|
|
public DataLayer(bool enableRedisMsg)
|
|
{
|
|
initTA();
|
|
setupConnectionStringBase();
|
|
|
|
// aggiunta x gestione timeout esteso (ove necessario)!
|
|
fixCommandTimeout();
|
|
|
|
// init oggetto MapoDb
|
|
MapoDbObj = new MapoDb();
|
|
|
|
if (enableRedisMsg)
|
|
{
|
|
// init message channel...
|
|
BroadastMsgPipe = new MessagePipe(connRedis, Constants.BROADCAST_M_PIPE);
|
|
}
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Hash dati MSE
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string hMSE
|
|
{
|
|
get => mHash("hMSE_DATA");
|
|
}
|
|
|
|
public static string redKeyArtUsed
|
|
{
|
|
get => mHash($"CACHE:CheckArtUsed");
|
|
}
|
|
|
|
public static string redKeyRawTransfData
|
|
{
|
|
get => mHash($"RAW:TRANSFER");
|
|
}
|
|
|
|
public static string redKeyTabCheckArt
|
|
{
|
|
get => mHash($"CACHE:TabCheckArt");
|
|
}
|
|
|
|
public MessagePipe BroadastMsgPipe { get; set; } = null;
|
|
|
|
/// <summary>
|
|
/// Cognome Nome da MatrOpr in sessione
|
|
/// </summary>
|
|
public string CognomeNomeOpr
|
|
{
|
|
get
|
|
{
|
|
// cerco operatore...
|
|
string answ = "";
|
|
try
|
|
{
|
|
DS_applicazione.AnagraficaOperatoriRow oper = taOp.getByMatrOpr(MatrOpr)[0];
|
|
answ = string.Format("{0} {1}", oper.Cognome, oper.Nome);
|
|
}
|
|
catch { }
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Oggetto statico connessione redis
|
|
/// </summary>
|
|
public ConnectionMultiplexer connRedis
|
|
{
|
|
get
|
|
{
|
|
return lazyConnection.Value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dati MSE serializzati in REDIS (get/set)
|
|
/// </summary>
|
|
public string currMSE
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
Log.Info("Richiesta MSE da REDIS");
|
|
answ = cMemLayer.getRSV(hMSE);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
int MSE_cacheDuration = cMemLayer.CRI("MSE_cacheDuration");
|
|
cMemLayer.setRSV(hMSE, value, MSE_cacheDuration);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dati RawTransfer serializzati in REDIS (get/set)
|
|
/// </summary>
|
|
public string lastRawTrasfData
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
Log.Info("Richiesta rawTransfData da REDIS");
|
|
answ = cMemLayer.getRSV(redKeyRawTransfData);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
cMemLayer.setRSV(redKeyRawTransfData, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// MatrOpr in sessione
|
|
/// </summary>
|
|
public int MatrOpr
|
|
{
|
|
get
|
|
{
|
|
int idx = 0;
|
|
try
|
|
{
|
|
idx = cMemLayer.IntSessionObj("MatrOpr");
|
|
}
|
|
catch { }
|
|
return idx;
|
|
}
|
|
set
|
|
{
|
|
cMemLayer.setSessionVal("MatrOpr", value);
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Hash dati ConfFlux x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string confFluxMaccHash(string idxMacchina)
|
|
{
|
|
return mHash($"MachineConfFlux:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati di configurazione IOB in formato YAML x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string ConfYamlHash(string idxMacchina)
|
|
{
|
|
return mHash($"IOB:{idxMacchina}:ConfYaml");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati tabella AnagStati macchina
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string currAnagStatiMacc()
|
|
{
|
|
return mHash(string.Format("Anag:StatiMacc"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati Current ODL x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string currODLHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("CurrODL:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati Current ODL ROW x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string currOdlRowHash(string idxMacchina)
|
|
{
|
|
return mHash($"CurrOdlRow:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati CurrentParameters x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string currParametersHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("CurrentParameters:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati Current StatoMacchina x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string currStatoMaccHash(string idxMacchina)
|
|
{
|
|
return mHash($"CurrStatoMacc:{idxMacchina}");
|
|
}
|
|
|
|
public static List<T> DataTableToList<T>(DataTable dt) where T : class, new()
|
|
{
|
|
List<T> lstItems = new List<T>();
|
|
if (dt != null && dt.Rows.Count > 0)
|
|
foreach (DataRow row in dt.Rows)
|
|
lstItems.Add(ConvertDataRowToGenericType<T>(row));
|
|
else
|
|
lstItems = null;
|
|
return lstItems;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati Dossier (last) x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string dossLastMaccHash(string idxMacchina)
|
|
{
|
|
return mHash($"MachineDossierLast:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati STATUS x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string dtMaccHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("DtMac:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati EXE TASK x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string exeTaskHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("ExeTask:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati FluxLog (iniziale) x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string fluxLogFirstMaccHash(string idxMacchina)
|
|
{
|
|
return mHash($"MachineFluxLogFirst:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati PODL ROW x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string getPOdlRowHash(int idxPODL)
|
|
{
|
|
return mHash($"PODLRow:{idxPODL}");
|
|
}
|
|
|
|
/// <summary> Hash dati relativi all'associazione macchina <--> IOB </summary> <param
|
|
/// name="IdxMacchina">Macchina</param> <returns></returns>
|
|
public static string hIobDict(string IdxMacchina)
|
|
{
|
|
return mHash($"IOB:{IdxMacchina}:CurrInfo");
|
|
}
|
|
|
|
/// <summary> Hash dati relativi all'associazione macchina <--> IOB </summary> <param
|
|
/// name="IdxMacchina">Macchina PRINCIPALE</param> <returns></returns>
|
|
public static string hM2IOB(string IdxMacchina)
|
|
{
|
|
return mHash(string.Format("hM2IOB:{0}", IdxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati relativi a macchina + IOB + conf speciali
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">Macchina</param>
|
|
/// <returns></returns>
|
|
public static string hMachineIobConf(string IdxMacchina)
|
|
{
|
|
return mHash($"IOB:{IdxMacchina}:MachIobConf");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati Macchine Multi SM Ingressi
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">Macchina PRINCIPALE</param>
|
|
/// <returns></returns>
|
|
public static string hMSMI(string IdxMacchina)
|
|
{
|
|
return mHash(string.Format("hMSMI:{0}", IdxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati STATE MACHINE INGRESSI x la FAMIGLIA INGRESSI specificata (per completare poi
|
|
/// manca singolo micro stato corrente + valore letto x definire chiave)
|
|
/// </summary>
|
|
/// <param name="idxFamIn"></param>
|
|
/// <returns></returns>
|
|
public static string hSMI(int idxFamIn)
|
|
{
|
|
return mHash(string.Format("hSMI:{0}", idxFamIn));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati BUFFER x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="bufferName"></param>
|
|
/// <returns></returns>
|
|
public static string LiveBufferHash(string idxMacchina, string bufferName)
|
|
{
|
|
return mHash($"LIVE:{idxMacchina}:{bufferName}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati LIVE x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string LiveCurrValHash(string idxMacchina)
|
|
{
|
|
return mHash($"LIVE:{idxMacchina}:CURR_VAL");
|
|
}
|
|
|
|
/// <summary>
|
|
/// KEY x i dati del FLog della machina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="flog"></param>
|
|
/// <returns></returns>
|
|
public static string LiveFLogKeyHash(string idxMacchina, string flog)
|
|
{
|
|
return mHash($"FLOG:{idxMacchina}:{flog}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati MemoryMap x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string memMapHash(string idxMacchina)
|
|
{
|
|
return mHash($"MemMap:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash Redis contenente i dati MP di una specifico TYPE (es StatusMacchina,
|
|
/// StateMachineIngressi, ...)
|
|
/// </summary>
|
|
/// <param name="dataType"></param>
|
|
/// <returns></returns>
|
|
public static string mHash(string dataType)
|
|
{
|
|
return cMemLayer.redHash(dataType);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati OPT PARAMETERS x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string optParHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("OptPar:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati COUNTER x la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string pzCountHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("PzCount:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati SAVED (EXE) TASK x la macchina specificata x poter ripristinare in caso di
|
|
/// perdita valore WRITE
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string savedTaskHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("SavedTask:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash dati STATUS x la macchina specificata.
|
|
/// - dati ODL
|
|
/// - dati articolo
|
|
/// - dati produzione corrente
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string stMaccHash(string idxMacchina)
|
|
{
|
|
return mHash(string.Format("StMac:{0}", idxMacchina));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash x VETO force Start PODL la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string vetoForceStartPOdlMaccHash(string idxMacchina)
|
|
{
|
|
return mHash($"VetoStartPOdlMacc:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hash x VETO dello SPLIT ODL la macchina specificata
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public static string vetoSplitOdlMaccHash(string idxMacchina)
|
|
{
|
|
return mHash($"VetoOdlMacc:{idxMacchina}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva richiesta azione
|
|
/// </summary>
|
|
/// <param name="act2save"></param>
|
|
/// <returns></returns>
|
|
public bool ActionSetReq(DisplayAction act2save)
|
|
{
|
|
bool fatto = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// cerco in redis...
|
|
string rawData = JsonConvert.SerializeObject(act2save);
|
|
// invio broadcast + salvo in redis
|
|
BroadastMsgPipe.saveAndSendMessage(Constants.redisActionReq, rawData);
|
|
fatto = true;
|
|
//await redisDb.StringSetAsync(redisActionReq, rawData);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Info($"ActionSetReq REDIS send to broadcast + Write cache: {ts.TotalMilliseconds}ms");
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// verifica se sia da reinviare un task alla macchina dall'elenco di quelli salvati (in
|
|
/// modalità upsert) se non scaduti
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="taskKey"></param>
|
|
/// <param name="taskVal"></param>
|
|
/// <returns></returns>
|
|
public bool addCheckTask4Machine(string idxMacchina, taskType taskKey, string taskVal)
|
|
{
|
|
bool answ = false;
|
|
string currHash = exeTaskHash(idxMacchina);
|
|
Log.Info($"addCheckTask4Machine idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
|
|
try
|
|
{
|
|
Dictionary<string, string> savedTask = mSavedTaskMacchina(idxMacchina);
|
|
// cerco valore saved
|
|
string savedVal = savedTask[taskKey.ToString()];
|
|
// se ho un valore != "" --> rimetto in coda di invio...
|
|
if (!string.IsNullOrEmpty(savedVal) && (savedVal != taskVal))
|
|
{
|
|
// leggo task attuali...
|
|
Dictionary<string, string> currTask = mTaskMacchina(idxMacchina);
|
|
// rimetto in task da eseguire...
|
|
currTask[taskKey.ToString()] = savedVal;
|
|
answ = cMemLayer.redSaveHashDict(currHash, currTask);
|
|
Log.Info($"re-issued task4machine: idxMacchina: {idxMacchina} | taskKey: {taskKey} | savedVal: {savedVal}");
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un PARAMETRO OPZIONALE all'elenco di quelli salvati (in modalità upsert)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="taskKey"></param>
|
|
/// <param name="taskVal"></param>
|
|
/// <returns></returns>
|
|
public bool addOptPar4Machine(string idxMacchina, string taskKey, string taskVal)
|
|
{
|
|
bool answ = false;
|
|
string currHash = optParHash(idxMacchina);
|
|
try
|
|
{
|
|
// leggo task attuali...
|
|
var currVal = mOptParMacchina(idxMacchina);
|
|
currVal[taskKey] = taskVal;
|
|
answ = cMemLayer.redSaveHashDict(currHash, currVal);
|
|
}
|
|
catch { }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un task all'elenco di quelli salvati (in modalità upsert)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="taskKey"></param>
|
|
/// <param name="taskVal"></param>
|
|
/// <returns></returns>
|
|
public bool addTask4Machine(string idxMacchina, taskType taskKey, string taskVal)
|
|
{
|
|
bool answ = false;
|
|
string currHash = exeTaskHash(idxMacchina);
|
|
string currSavedParHash = savedTaskHash(idxMacchina);
|
|
Dictionary<string, string> currTask = new Dictionary<string, string>();
|
|
Dictionary<string, string> savedTask = new Dictionary<string, string>();
|
|
try
|
|
{
|
|
//Log.Info($"Request: idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
|
|
// leggo task attuali...
|
|
currTask = mTaskMacchina(idxMacchina);
|
|
if (currTask.ContainsKey($"{taskKey}"))
|
|
{
|
|
currTask[$"{taskKey}"] = taskVal;
|
|
}
|
|
else
|
|
{
|
|
currTask.Add($"{taskKey}", taskVal);
|
|
}
|
|
answ = cMemLayer.redSaveHashDict(currHash, currTask);
|
|
Log.Info($"Task ADD - idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
|
|
}
|
|
catch { }
|
|
// verifico in base al tipo di task se fare backup...
|
|
switch (taskKey)
|
|
{
|
|
case taskType.setArt:
|
|
case taskType.setComm:
|
|
case taskType.setPzComm:
|
|
case taskType.setProg:
|
|
// leggo task SALVATI attuali...
|
|
savedTask = mSavedTaskMacchina(idxMacchina);
|
|
savedTask[taskKey.ToString()] = taskVal;
|
|
answ = cMemLayer.redSaveHashDict(currSavedParHash, savedTask);
|
|
break;
|
|
|
|
case taskType.endProd:
|
|
// salvo un DICT vuoto x resettare
|
|
savedTask = new Dictionary<string, string>();
|
|
answ = cMemLayer.redSaveHashDict(currSavedParHash, savedTask);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco stati macchina
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public DS_applicazione.AnagraficaStatiDataTable AnagraficaStati()
|
|
{
|
|
DS_applicazione.AnagraficaStatiDataTable answTab = null;
|
|
// cerco in cache...
|
|
string rCall = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("hasAnagStati");
|
|
try
|
|
{
|
|
rCall = cMemLayer.getRSV(currAnagStatiMacc());
|
|
if (!string.IsNullOrEmpty(rCall))
|
|
{
|
|
answTab = JsonConvert.DeserializeObject<DS_applicazione.AnagraficaStatiDataTable>(rCall);
|
|
}
|
|
else
|
|
{
|
|
//2020.01.31 nuovo obj x evitare concorrenza
|
|
MapoDb man = new MapoDb();
|
|
answTab = man.taAnagSt.GetData();
|
|
//resultList = MapoDbObj.taAnagSt.GetData();
|
|
// salvo in redis...
|
|
rCall = JsonConvert.SerializeObject(answTab);
|
|
int anagrCacheDur = cMemLayer.CRI("anagrCacheDur");
|
|
cMemLayer.setRSV(currAnagStatiMacc(), rCall, anagrCacheDur);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero currODLRow{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answTab = MapoDbObj.taAnagSt.GetData();
|
|
}
|
|
return answTab;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua split ODL
|
|
/// </summary>
|
|
/// <param name="idxMacchina">macchina</param>
|
|
/// <param name="doConfirm">effettuare conferma qty</param>
|
|
/// <param name="qtyFromLast">imposta la qty prox ODL da ODL che si chiude</param>
|
|
/// <param name="matrOpr">matricola operatore</param>
|
|
/// <param name="roundStep">
|
|
/// STEP x cui arrotondare la quantità prox ODL (corrente come riferimento)
|
|
/// </param>
|
|
/// <param name="keyRichiesta">Cod ext da associare all'ODL</param>
|
|
/// <returns></returns>
|
|
public string AutoStartOdl(string idxMacchina, bool doConfirm, bool qtyFromLast, int matrOpr, int roundStep = 100, string keyRichiesta = "")
|
|
{
|
|
string answ = "KO";
|
|
DateTime adesso = DateTime.Now;
|
|
// verifico NON CI SIA un veto a NUOVI split... 2 min di default...
|
|
string redKey = vetoSplitOdlMaccHash(idxMacchina);
|
|
string rawData = cMemLayer.getRSV(redKey);
|
|
if (string.IsNullOrEmpty(rawData))
|
|
{
|
|
// registro VETO x altri split... 5 minuti
|
|
cMemLayer.setRSV(redKey, $"Inizio SPLIT-ODL {adesso}", 300);
|
|
// calcolo la qta da gestire
|
|
int qtyConf = 0;
|
|
int qtyNew = 0;
|
|
int qtyScarto = 0;
|
|
if (doConfirm)
|
|
{
|
|
DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd;
|
|
DS_ProdTempi.StatoProdRow statoProd;
|
|
try
|
|
{
|
|
rigaProd = taPzProd2conf.GetData(idxMacchina)[0];
|
|
statoProd = taStatoProd.GetData(idxMacchina, adesso)[0];
|
|
qtyConf = rigaProd.pezziNonConfermati;
|
|
qtyScarto = statoProd.Pz2RecScarto;
|
|
// calcolo nuovi pezzi da confermare
|
|
if (qtyFromLast)
|
|
{
|
|
roundStep = roundStep == 0 ? 1 : roundStep;
|
|
double ratio = (double)qtyConf / roundStep;
|
|
qtyNew = (int)Math.Round(Math.Ceiling(ratio) * roundStep, 0);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore recupero pezzi da confermare per la macchina {0}{1}{2}", idxMacchina, Environment.NewLine, exc), tipoLog.ERROR);
|
|
}
|
|
}
|
|
|
|
// proseguo
|
|
DS_ProdTempi.ODLDataTable currData = null;
|
|
// chiamo metodo redis/db...
|
|
try
|
|
{
|
|
// recupero ODL corrente
|
|
currData = currODLRowTab(idxMacchina);
|
|
if (currData.Count > 0)
|
|
{
|
|
// preparo var x master/slave
|
|
bool isMachMaster = this.isMaster(idxMacchina);
|
|
DS_ProdTempi.Macchine2SlaveDataTable slaveList = isMachMaster ? taM2S.getByMaster(idxMacchina) : new DS_ProdTempi.Macchine2SlaveDataTable();
|
|
// registro un evento di inizio attrezzaggio (idxTipoEv = 2)
|
|
int idxEvento = 2;
|
|
Log.Info($"Invio evento ODL-SPLIT per macchina {idxMacchina} | ev: {idxEvento} | art: {currData[0].CodArticolo} | qty conf: {qtyConf} | sty sca: {qtyScarto} | new qty: {qtyNew}", tipoLog.INFO);
|
|
|
|
inputComandoMapo resCmd = scriviRigaEventoBarcode(idxMacchina, idxEvento, currData[0].CodArticolo, "ODL-SPLIT", 0, "", adesso, adesso);
|
|
if (doConfirm)
|
|
{
|
|
// attendo 100 msec
|
|
Thread.Sleep(100);
|
|
adesso = DateTime.Now;
|
|
// chiamo conferma produzione...
|
|
try
|
|
{
|
|
string chiamata = confRett ? "confermaProdMacchinaFull" : "confermaProdMacchina";
|
|
Log.Info($"Chiamata a {chiamata} con parametri {currData[0].IdxMacchina} |{MatrOpr} | {DateTime.Now.AddDays(-10)} | {DateTime.Now} | {qtyConf} | 0 | {qtyScarto} | {DateTime.Now} | false", tipoLog.INFO);
|
|
string idxMacchinaSel = currData[0].IdxMacchina;
|
|
bool fatto = false;
|
|
if (confRett)
|
|
{
|
|
// confermo al netto dei pezzi lasciati...
|
|
fatto = confermaProdMacchinaFull(idxMacchinaSel, cMemLayer.CRI("modoConfProd"), qtyConf, 0, qtyScarto, adesso, matrOpr);
|
|
if (cMemLayer.CRB("SlaveConfirmPzProd"))
|
|
{
|
|
foreach (var machine in slaveList)
|
|
{
|
|
confermaProdMacchinaFull(machine.IdxMacchinaSlave, cMemLayer.CRI("modoConfProd"), qtyConf, 0, qtyScarto, adesso, matrOpr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fatto = confermaProdMacchina(idxMacchinaSel, cMemLayer.CRI("modoConfProd"), qtyConf, qtyScarto, adesso, matrOpr);
|
|
if (cMemLayer.CRB("SlaveConfirmPzProd"))
|
|
{
|
|
foreach (var machine in slaveList)
|
|
{
|
|
confermaProdMacchina(idxMacchinaSel, cMemLayer.CRI("modoConfProd"), qtyConf, qtyScarto, adesso, matrOpr);
|
|
}
|
|
}
|
|
}
|
|
if (!fatto)
|
|
{
|
|
Log.Info($"ERRORE in chiamata {chiamata}", tipoLog.ERROR);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in ConfermaProduzione{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
// 2025.02.19 portato da 100 a 1000 ms attesa x evitare che ODL sia avviato PRIMA della conferma
|
|
// attendo 1000 msec x chiudere ODL
|
|
Thread.Sleep(1000);
|
|
// chiamo splitOdl
|
|
MapoDbObj.taODL.autoStart(currData[0].IdxODL, 0, idxMacchina, currData[0].TCRichAttr, currData[0].PzPallet, $"Nuovo ODL da forceSplitOdl.autoStart", true, qtyNew, keyRichiesta);
|
|
// elimino eventuale ODL precedente...
|
|
string rKey = cMemLayer.redHash($"ODL:{idxMacchina}");
|
|
cMemLayer.setRSV(rKey, "");
|
|
// ricalcola ODL macchina
|
|
var newOdl = currODL(idxMacchina, true);
|
|
// attendo 1000 msec
|
|
Thread.Sleep(1000);
|
|
adesso = DateTime.Now;
|
|
// registro fine ODL (idxTipoEv = 1)
|
|
idxEvento = 1;
|
|
Log.Info($"Invio evento FINE ODL-SPLIT per macchina {idxMacchina}, evento {idxEvento}, articolo {currData[0].CodArticolo}", tipoLog.INFO);
|
|
resCmd = scriviRigaEventoBarcode(idxMacchina, idxEvento, currData[0].CodArticolo, "ODL-START");
|
|
// invio eventi setup a macchina....
|
|
string setArtVal = $"{currData[0].CodArticolo}";
|
|
string setPzCommVal = $"{qtyNew}";
|
|
string setCommVal = $"ODL{newOdl}";
|
|
if (!string.IsNullOrEmpty(keyRichiesta))
|
|
{
|
|
setCommVal = $"{keyRichiesta} ODL{newOdl}";
|
|
}
|
|
try
|
|
{
|
|
// invio task caricamento dati ODL
|
|
addTask4Machine(idxMacchina, taskType.setArt, setArtVal);
|
|
addTask4Machine(idxMacchina, taskType.setComm, setCommVal);
|
|
addTask4Machine(idxMacchina, taskType.setPzComm, setPzCommVal);
|
|
updateMachineParameter(idxMacchina, "setArt", setArtVal);
|
|
updateMachineParameter(idxMacchina, "setComm", setCommVal);
|
|
updateMachineParameter(idxMacchina, "setPzComm", setPzCommVal);
|
|
}
|
|
catch
|
|
{ }
|
|
// chiamo refresh MSE
|
|
taMSE.forceRecalc(0, idxMacchina);
|
|
// resetto stato macchina...
|
|
cMemLayer.redDelKey(currStatoMaccHash(idxMacchina));
|
|
answ = "OK";
|
|
Log.Info($"Effettuato reset e ricalcoli x split ODL per macchina {idxMacchina}", tipoLog.INFO);
|
|
// se è una master richiamo fix x child...
|
|
if (isMachMaster)
|
|
{
|
|
string ts = "";
|
|
string outData = "";
|
|
taODL.fixMachineSlave(idxMacchina, 30, 1);
|
|
foreach (var machine in slaveList)
|
|
{
|
|
// invio chiusura attrezzaggio
|
|
ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
|
|
outData = $"TS:{ts}|MATR:{MatrOpr}|ODL:{newOdl}";
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.fixStopSetup, outData);
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.forceResetPzCount, outData);
|
|
|
|
// invio task caricamento dati ODL
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.setArt, setArtVal);
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.setComm, setCommVal);
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.setPzComm, setPzCommVal);
|
|
|
|
updateMachineParameter(machine.IdxMacchinaSlave, "setArt", setArtVal);
|
|
updateMachineParameter(machine.IdxMacchinaSlave, "setComm", setCommVal);
|
|
updateMachineParameter(machine.IdxMacchinaSlave, "setPzComm", setPzCommVal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in forceSplitOdl{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Info($"VETO ATTIVO | Richiesto forceSplitOdl per impianto {idxMacchina} | impossibile procedere");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// controlla se da il segnale di "microstato" deriva un evento da generare - modalità OFFLINE
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina</param>
|
|
/// <param name="valore">valore ingresso</param>
|
|
/// <param name="dtEve">data-ora evento (server)</param>
|
|
/// <param name="contatore">sequenza dati inviati</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo checkMicroStato(string idxMacchina, string valore, DateTime dtEve, string contatore)
|
|
{
|
|
int _logLevel = cMemLayer.CRI("_logLevel");
|
|
// recupero SE IMPIEGATO REDIS i valori del Dictionary della macchina...
|
|
Dictionary<string, string> datiMacc = mDatiMacchine(idxMacchina);
|
|
|
|
if (_logLevel > 6)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt]{2}---------------------------{2}Richiesta verifica INPUT per Macchina {0}, seriale {1}", idxMacchina, valore, Environment.NewLine), tipoLog.INFO);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
DS_applicazione.TransizioneIngressiDataTable TabTransIn;
|
|
DS_applicazione.TransizioneIngressiRow rigaTransIn = null;
|
|
// verifico se esista la macchina altrimenti la creo... REDIS compliant
|
|
verificaIdxMacchina(idxMacchina);
|
|
string CodArticolo = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
try
|
|
{
|
|
// esecuzione in REDIS
|
|
CodArticolo = datiMacc["CodArticolo"];
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
// esecuzione in DB... recupero CodArticolo corretto
|
|
try
|
|
{
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione
|
|
// NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// 2017.07.10 forzo init x errori "sovrapposizioni"
|
|
taDatiMacchine = new DS_ProdTempiTableAdapters.DatiMacchineTableAdapter();
|
|
}
|
|
CodArticolo = taDatiMacchine.getByIdx(idxMacchina)[0].CodArticolo_A;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_4a] - Eccezione in recupero CodArticolo:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
// recupero next microstato
|
|
int? valINT = 0;
|
|
try
|
|
{
|
|
valINT = int.Parse(valore, System.Globalization.NumberStyles.HexNumber);
|
|
// esecuzione in REDIS...
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
try
|
|
{
|
|
int idxFamIn = Convert.ToInt32(datiMacc["IdxFamIn"]);
|
|
int idxMicroStato = Convert.ToInt32(datiMacc["IdxMicroStato"]);
|
|
int valIOB = Convert.ToInt32(valINT);
|
|
int idxTipoEv = 0;
|
|
int next_idxMS = idxMicroStato;
|
|
// verifico esistenza tab SMI...
|
|
string fiHASH = DataLayer.hSMI(idxFamIn);
|
|
string todoSMI = "";
|
|
bool trovato = cMemLayer.redHashPresentSz(fiHASH);
|
|
if (!trovato)
|
|
{
|
|
// ricarico tabella!
|
|
KeyValuePair<string, string>[] valori = mTabSMI(idxFamIn);
|
|
}
|
|
// recupero singolo valore (stringa) x chiave
|
|
todoSMI = valoreSMI(idxFamIn, idxMicroStato, valIOB);
|
|
// solo se ho trovato un risultato nella tab SMI della famiglia macchina...
|
|
if (todoSMI != "")
|
|
{
|
|
// splitto e salvo valori OUT...
|
|
string[] valori = todoSMI.Split('_');
|
|
idxTipoEv = Convert.ToInt32(valori[0]);
|
|
next_idxMS = Convert.ToInt32(valori[1]);
|
|
// creo la riga tipizzata dai dati di redis x procedere...
|
|
DS_applicazione.TransizioneIngressiDataTable tab = new DS_applicazione.TransizioneIngressiDataTable();
|
|
rigaTransIn = tab.NewTransizioneIngressiRow();
|
|
rigaTransIn.IdxFamigliaIngresso = idxFamIn;
|
|
rigaTransIn.IdxMicroStato = idxMicroStato;
|
|
rigaTransIn.ValoreIngresso = valIOB;
|
|
rigaTransIn.IdxTipoEvento = idxTipoEv;
|
|
rigaTransIn.next_IdxMicroStato = next_idxMS;
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione
|
|
// NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// 2017.06.09 forzo init x errori "sovrapposizioni"
|
|
MapoDbObj.taTransIngr = new DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
|
|
}
|
|
TabTransIn = MapoDbObj.taTransIngr.getByIdxMacchinaValore(idxMacchina, valINT);
|
|
if (TabTransIn.Rows.Count > 0)
|
|
{
|
|
rigaTransIn = TabTransIn[0];
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_5a] - - Eccezione in recupero riga Trans ingressi per idxMacchina {3} e valore {2}:{0}{1}", Environment.NewLine, exc, valINT, idxMacchina), tipoLog.EXCEPTION);
|
|
}
|
|
// effettuo update vari SU DB!!!
|
|
if (rigaTransIn != null)
|
|
{
|
|
try
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_6a] - Salvo Update Microstato:{0}macchina: {1} | valore seriale: {2} | next micro stato: {3}", Environment.NewLine, idxMacchina, valINT, rigaTransIn.next_IdxMicroStato), tipoLog.INFO);
|
|
}
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione
|
|
// NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// 2017.06.09 forzo init x errori "sovrapposizioni"
|
|
MapoDbObj.taMSM = new DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter();
|
|
}
|
|
// salvo nuovo microstato...
|
|
MapoDbObj.taMSM.updateQuery(rigaTransIn.next_IdxMicroStato, dtEve, valore, idxMacchina);
|
|
// controllo se c'è evento
|
|
if (rigaTransIn.IdxTipoEvento > 0)
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_7a] - Salvo evento:{0}macchina: {1} | tipoEvento: {2} | CodArticolo: {3} | contatore: {4} | valore: {5}", Environment.NewLine, idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo, contatore, valore), tipoLog.INFO);
|
|
}
|
|
string valEsteso = string.Format("[{0}] {1}", contatore.PadLeft(3, '0'), valore);
|
|
// aggiunto contatore!
|
|
answ = scriviRigaEvento(idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo, valEsteso, 0, "-", dtEve, DateTime.Now);
|
|
// 2017.09.12 SE era in modalità redis RICARICA dati macchina...
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
resetDatiMacchina(idxMacchina);
|
|
}
|
|
if (_logLevel > 5)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_a] - Macchina {0} | seriale(INT) {1} | valEsteso {3} | answ {4}{2}---------------------------{2}", idxMacchina, valINT, Environment.NewLine, valEsteso, answ), tipoLog.INFO);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_8a] - Eccezione:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// controlla se da il segnale di "microstato" deriva un evento da generare - modalità OFFLINE
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina</param>
|
|
/// <param name="valore">valore ingresso</param>
|
|
/// <param name="dtEve">data-ora evento (server)</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo checkMicroStato(string idxMacchina, string valore, DateTime dtEve)
|
|
{
|
|
if (cMemLayer.CRI("_logLevel") > 6)
|
|
{
|
|
Log.Info(string.Format("{2}---------------------------{2}Richiesta verifica INPUT per Macchina {0}, seriale {1}", idxMacchina, valore, Environment.NewLine), tipoLog.INFO);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
DS_applicazione.TransizioneIngressiDataTable TabTransIn;
|
|
DS_applicazione.TransizioneIngressiRow rigaTransIn = null;
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(idxMacchina);
|
|
string CodArticolo = "";
|
|
// recupero CodArticolo corretto
|
|
try
|
|
{
|
|
// 2017.07.10 forzo init x errori "sovrapposizioni"
|
|
taDatiMacchine = new DS_ProdTempiTableAdapters.DatiMacchineTableAdapter();
|
|
CodArticolo = taDatiMacchine.getByIdx(idxMacchina)[0].CodArticolo_A;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_4b] - Eccezione in recupero CodArticolo:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// recupero next microstato
|
|
//int? valINT = Convert.ToInt32(valore);
|
|
int? valINT = 0;
|
|
try
|
|
{
|
|
// 2017.06.09 forzo init x errori "sovrapposizioni"
|
|
MapoDbObj.taTransIngr = new DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
|
|
valINT = int.Parse(valore, System.Globalization.NumberStyles.HexNumber);
|
|
TabTransIn = MapoDbObj.taTransIngr.getByIdxMacchinaValore(idxMacchina, valINT);
|
|
if (TabTransIn.Rows.Count > 0)
|
|
{
|
|
rigaTransIn = TabTransIn[0];
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_5b] - Eccezione in recupero riga Trans ingressi per idxMacchina {3} e valore {2}:{0}{1}", Environment.NewLine, exc, valINT, idxMacchina), tipoLog.EXCEPTION);
|
|
}
|
|
int _logLevel = cMemLayer.CRI("_logLevel");
|
|
// effettuo update vari
|
|
if (rigaTransIn != null)
|
|
{
|
|
try
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_6b] - Salvo Update Microstato:{0}macchina: {1} | valore seriale: {2} | next micro stato: {3}", Environment.NewLine, idxMacchina, valINT, rigaTransIn.next_IdxMicroStato), tipoLog.INFO);
|
|
}
|
|
// salvo nuovo microstato...
|
|
MapoDbObj.taMSM.updateQuery(rigaTransIn.next_IdxMicroStato, dtEve, valore, idxMacchina);
|
|
// controllo se c'è evento
|
|
if (rigaTransIn.IdxTipoEvento > 0)
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_7b] - Salvo evento:{0}macchina: {1} | tipoEvento: {2} | CodArticolo: {3}", Environment.NewLine, idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo), tipoLog.INFO);
|
|
}
|
|
answ = scriviRigaEvento(idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo, valore, 0, "-", dtEve, DateTime.Now);
|
|
if (_logLevel > 5)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_b] -Macchina {0}, seriale(INT) {1}{2}---------------------------{2}", idxMacchina, valINT, Environment.NewLine), tipoLog.INFO);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[ChkMiSt_8b] - Eccezione:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// controlla se da il segnale di "microstato" deriva un evento da generare
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="valore"></param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo checkMicroStato(string idxMacchina, string valore)
|
|
{
|
|
// wrapper ad ora corrente...
|
|
return checkMicroStato(idxMacchina, valore, DateTime.Now);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
|
|
/// --> dtEvent)
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina da confermare</param>
|
|
/// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
|
|
/// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
|
|
/// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
|
|
/// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
|
|
/// <returns></returns>
|
|
public bool confermaProdMacchina(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzScarto, DateTime DataOraApp, int matrOpr)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd = taPzProd2conf.GetData(idxMacchina.ToString())[0];
|
|
taPzProd2conf.stp_ConfermaProduzCompleta(idxMacchina, matrOpr, rigaProd.DataFrom, DataOraApp, numPzConfermati, numPzScarto, modoConfProd, DataOraApp, true);
|
|
// indico eseguito!
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Errore in conferma prod macchina:{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
|
|
/// --> dtEvent)
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina da confermare</param>
|
|
/// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
|
|
/// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
|
|
/// <param name="numPzLasciati">
|
|
/// qta pezzi LASCIATI alla macchina da confermare (2 eventi 121 rettifica neg/pos)
|
|
/// </param>
|
|
/// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
|
|
/// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
|
|
/// <returns></returns>
|
|
public bool confermaProdMacchinaFull(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzLasciati, int numPzScarto, DateTime DataOraApp, int matrOpr)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd = taPzProd2conf.GetData(idxMacchina.ToString())[0];
|
|
taPzProd2conf.stp_ConfermaProduzCompletaFull(idxMacchina, matrOpr, rigaProd.DataFrom, DataOraApp, numPzConfermati, numPzLasciati, numPzScarto, modoConfProd, DataOraApp, true);
|
|
// indico eseguito!
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Errore in conferma prod macchina con rett ev121:{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce l'elenco codici flusso (da confFlux) x una macchina (se presenti) Impiegata
|
|
/// anche cache redis
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public List<string> confFluxMach(string idxMacchina)
|
|
{
|
|
List<string> resultList = new List<string>();
|
|
string rawData = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("confFluxMach");
|
|
string redKey = confFluxMaccHash(idxMacchina);
|
|
try
|
|
{
|
|
DataLayer man = new DataLayer();
|
|
rawData = cMemLayer.getRSV(redKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
var redisResult = JsonConvert.DeserializeObject<List<string>>(rawData);
|
|
resultList = redisResult != null ? redisResult : new List<string>();
|
|
}
|
|
else
|
|
{
|
|
resultList = man.taConfFlux
|
|
.GetData()
|
|
.Where(x => x.IdxMacchina == idxMacchina)
|
|
.Select(x => x.CodFlux)
|
|
.ToList();
|
|
// salvo in redis...
|
|
rawData = JsonConvert.SerializeObject(resultList);
|
|
int IO_CacheConfFluxMin = cMemLayer.CRI("IO_CacheConfFluxMin");
|
|
cMemLayer.setRSV(redKey, rawData, IO_CacheConfFluxMin * 60);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero confFluxMach{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
resultList = taConfFlux
|
|
.GetData()
|
|
.Where(x => x.IdxMacchina == idxMacchina)
|
|
.Select(x => x.CodFlux)
|
|
.ToList();
|
|
}
|
|
if (resultList == null)
|
|
{
|
|
resultList = new List<string>();
|
|
}
|
|
return resultList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore dell'ODL corrente (ODL deve esserci per gestione contapezzi, senza
|
|
/// ODL NO invio/gestione ODL)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string currODL(string idxMacchina)
|
|
{
|
|
string answ = "";
|
|
string rCall = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("hasODL");
|
|
try
|
|
{
|
|
rCall = cMemLayer.getRSV(currODLHash(idxMacchina));
|
|
if (!string.IsNullOrEmpty(rCall))
|
|
{
|
|
answ = rCall;
|
|
}
|
|
else
|
|
{
|
|
answ = getCurrODL(idxMacchina);
|
|
// salvo in redis...
|
|
saveCurrODL(idxMacchina, answ);
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore dell'ODL corrente (ODL deve esserci per gestione contapezzi, senza
|
|
/// ODL NO invio/gestione ODL)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="forceDb">indica se forzare lettura da db (true) o meno</param>
|
|
/// <returns></returns>
|
|
public string currODL(string idxMacchina, bool forceDb)
|
|
{
|
|
string answ = "";
|
|
// faccio comunque verifica se sia stato letto da poco il valore... x cui anche a fronte
|
|
// di richiesta lettura da DB per 3 sec tengo buono valore in cache redis...
|
|
string rKey = cMemLayer.redHash($"ODL:{idxMacchina}");
|
|
string _idxOdl = cMemLayer.getRSV(rKey);
|
|
if (forceDb)
|
|
{
|
|
if (!string.IsNullOrEmpty(_idxOdl))
|
|
{
|
|
answ = _idxOdl;
|
|
}
|
|
else
|
|
{
|
|
answ = getCurrODL(idxMacchina);
|
|
// salvo in redis...
|
|
saveCurrODL(idxMacchina, answ);
|
|
cMemLayer.setRSV(rKey, answ, 3);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answ = currODL(idxMacchina);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore dell'intera RIGA ODL corrente (da redis o da DB se non trovata...)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public DS_ProdTempi.ODLDataTable currODLRowTab(string idxMacchina)
|
|
{
|
|
DS_ProdTempi.ODLDataTable answTab = null;
|
|
string rCall = "";
|
|
string rKey = currOdlRowHash(idxMacchina);
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("hasODL_row");
|
|
try
|
|
{
|
|
rCall = cMemLayer.getRSV(rKey);
|
|
if (!string.IsNullOrEmpty(rCall))
|
|
{
|
|
answTab = JsonConvert.DeserializeObject<DS_ProdTempi.ODLDataTable>(rCall);
|
|
}
|
|
if (answTab == null || answTab.Count == 0)
|
|
{
|
|
// istanzio un NUOVO oggetto lettura
|
|
MapoDb connDb = new MapoDb();
|
|
answTab = connDb.currODLTab(idxMacchina);
|
|
// salvo in redis...
|
|
rCall = JsonConvert.SerializeObject(answTab);
|
|
int currOdlRowCacheDur = cMemLayer.CRI("currOdlRowCacheDur");
|
|
cMemLayer.setRSV(rKey, rCall, currOdlRowCacheDur);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero currODLRow{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// istanzio un NUOVO oggetto lettura
|
|
MapoDb connDb = new MapoDb();
|
|
answTab = connDb.currODLTab(idxMacchina);
|
|
}
|
|
return answTab;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore dell'intera RIGA stato macchina corrente (da redis o da DB se non trovata...)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public DS_applicazione.StatoMacchineDataTable currSMTab(string idxMacchina)
|
|
{
|
|
DS_applicazione.StatoMacchineDataTable answTab = null;
|
|
string rCall = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("hasStatoMacc");
|
|
try
|
|
{
|
|
rCall = cMemLayer.getRSV(currStatoMaccHash(idxMacchina));
|
|
if (!string.IsNullOrEmpty(rCall))
|
|
{
|
|
answTab = JsonConvert.DeserializeObject<DS_applicazione.StatoMacchineDataTable>(rCall);
|
|
}
|
|
else
|
|
{
|
|
// 2020.01.31 uso nuovo oggetto connessione
|
|
MapoDb man = new MapoDb();
|
|
answTab = man.currStatoMaccTab(idxMacchina);
|
|
//resultList = MapoDbObj.currStatoMaccTab(idxMacchina);
|
|
// salvo in redis...
|
|
rCall = JsonConvert.SerializeObject(answTab);
|
|
int currStatoMaccCacheDur = cMemLayer.CRI("currStatoMaccCacheDur");
|
|
cMemLayer.setRSV(currStatoMaccHash(idxMacchina), rCall, currStatoMaccCacheDur);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero currODLRow{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answTab = MapoDbObj.currStatoMaccTab(idxMacchina);
|
|
}
|
|
return answTab;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce l'elenco delle date dei dossier x una macchina (se presenti) Impiegata anche
|
|
/// cache redis
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public List<DateTime> dossierLastByMach(string idxMacchina)
|
|
{
|
|
List<DateTime> resultList = new List<DateTime>();
|
|
string rawData = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("dossierLastByMach");
|
|
string redKey = dossLastMaccHash(idxMacchina);
|
|
try
|
|
{
|
|
DataLayer man = new DataLayer();
|
|
rawData = cMemLayer.getRSV(redKey);
|
|
if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
|
|
{
|
|
var redisResult = JsonConvert.DeserializeObject<List<DateTime>>(rawData);
|
|
resultList = redisResult != null ? redisResult : new List<DateTime>();
|
|
}
|
|
else
|
|
{
|
|
resultList = man.taDOSS
|
|
.getLastByMacc(idxMacchina)
|
|
.Select(x => x.DtRif)
|
|
.ToList();
|
|
// salvo in redis...
|
|
rawData = JsonConvert.SerializeObject(resultList);
|
|
int IO_CacheDossLastMin = cMemLayer.CRI("IO_CacheDossLastMin");
|
|
cMemLayer.setRSV(redKey, rawData, IO_CacheDossLastMin * 60);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero dossierLastByMach{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
resultList = taDOSS
|
|
.getLastByMacc(idxMacchina)
|
|
.Select(x => x.DtRif)
|
|
.ToList();
|
|
}
|
|
if (resultList == null)
|
|
{
|
|
resultList = new List<DateTime>();
|
|
}
|
|
return resultList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Svuota la cache redis x l'elenco delle righe di confFlux x una macchina (se presenti)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool dossierLastByMachReset(string idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
string rawData = "";
|
|
string redKey = dossLastMaccHash(idxMacchina);
|
|
cMemLayer.setRSV(redKey, rawData, 1);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rimuove Key dell'ODL corrente x una data macchina IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string emptyCurrODL(string idxMacchina)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
cMemLayer.redDelKey(currODLHash(idxMacchina));
|
|
cMemLayer.redDelKey(currOdlRowHash(idxMacchina));
|
|
answ = "OK";
|
|
}
|
|
catch
|
|
{
|
|
answ = "KO";
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua enroll del device
|
|
/// </summary>
|
|
/// <param name="UserAuthKey"></param>
|
|
/// <param name="IPv4"></param>
|
|
/// <param name="DeviceName"></param>
|
|
/// <param name="Description"></param>
|
|
/// <param name="idxDipendente"></param>
|
|
/// <returns></returns>
|
|
public bool enrollDevice(string UserAuthKey, string IPv4, string DeviceName, string Description, int matricola)
|
|
{
|
|
bool fatto = false;
|
|
// in primis testo se dipendente ed authKey sono validi..
|
|
if (taOp.getByMatrAuthKey(matricola, UserAuthKey).Rows.Count > 0)
|
|
{
|
|
// salvo matrOpr
|
|
MatrOpr = matricola;
|
|
/************************************************
|
|
* Gestione riconoscimento devices
|
|
*
|
|
* - cerco IP del device, testo se è rete interna (A) o extranet/internet (B) cercando substring "localNet" da web.config
|
|
* (A): device interni: c'è un DHCP, e "dhcpLeaseTime" deve essere pari a lease time---
|
|
* - verifico se IP già in uso da un tempo < "dhcpLeaseTime" --> in questo caso segnalo errore e rimbalzo (NON permetto di registrare device a nuovo utente... sospetto uso "improprio" del device
|
|
* - se tempo > dhcpLeaseTime allora può aver cambiato IP: aggiorno IP e descrizione del device e proseguo
|
|
* (B): all'esterno vedo tutta una subnet NATtata con unico IP, non è + discriminante
|
|
* - le timbrature "da esterno" devono essere confermate (instrodurre "tipo timbratura" x cui interne sono autoconfermate, esterne sono "grayed" (da confermare, da admin o ad esempio se si accende secondo device utente entro 5/10 min)
|
|
* - le timbrature ext DOVREBBERO chiedere location (jScript?) e inviarla, visibile in conferma
|
|
*
|
|
*
|
|
* **********************************************/
|
|
// calcolo il secret...
|
|
DateTime adesso = DateTime.Now;
|
|
string Dominio = cMemLayer.CRS("dominio");
|
|
string UsrName = cMemLayer.CRS("user");
|
|
// recupero dati da matricola...
|
|
try
|
|
{
|
|
DataLayer_AnagGen.UTENTERow rigaUt = user_std.UtSn.rigaUtenteDaMatricola($"{matricola}");
|
|
if (rigaUt != null)
|
|
{
|
|
Dominio = rigaUt.DOMINIO;
|
|
UsrName = rigaUt.USER_NAME;
|
|
}
|
|
else
|
|
{
|
|
Log.Info($"Non sono riuscito a recuperare RIGA utente per matricola {matricola}", tipoLog.ERROR);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Log.Info($"Eccezione! non sono riuscito a recuperare utente per matricola {matricola}", tipoLog.ERROR);
|
|
Dominio = cMemLayer.CRS("dominio");
|
|
UsrName = cMemLayer.CRS("user");
|
|
}
|
|
string cookieName = cMemLayer.CRS("cookieName");
|
|
//DateTime expDate = DateTime.Now.AddDays(cMemLayer.CRI("cookieDayExpire"));
|
|
|
|
string cookieDayExpire = cMemLayer.CRS("cookieDayExpire").Replace(".", ",");
|
|
double dayExp = 1;
|
|
NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
|
|
CultureInfo culture = CultureInfo.CreateSpecificCulture("it-IT");
|
|
double.TryParse(cookieDayExpire, style, culture, out dayExp);
|
|
DateTime expDate = DateTime.Now.AddDays(dayExp);
|
|
string Secret = authProxy.getSecret(Dominio, UsrName, matricola, DeviceName, adesso);
|
|
string devSecret = SteamCrypto.EncryptString(Secret, cookieName);
|
|
try
|
|
{
|
|
// creo device + cookie!
|
|
fatto = authProxy.createNewCookie(Dominio, UsrName, matricola, DeviceName, Description, IPv4, cookieName, expDate);
|
|
// loggo!
|
|
Log.Info(string.Format("Effettuato enroll nuovo device: utente {0}\\{1} | matricola {2} | DeviceName {3} | Descrizione {4} | IP {5} | nome cookie {6} | valido sino a {7:yyyy/MM/dd HH:mm:ss}", Dominio, UsrName, matricola, DeviceName, Description, IPv4, cookieName, expDate));
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Errore enroll nuovo device:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce l'elenco delle data-ora di confFlux x una macchina (se presenti) Impiegata
|
|
/// anche cache redis
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="numMax">num record da recuperare</param>
|
|
/// <returns></returns>
|
|
public List<DateTime> fluxLogFirstByMach(string idxMacchina, int numMax = 10)
|
|
{
|
|
List<DateTime> resultList = new List<DateTime>();
|
|
string rawData = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("fluxLogFirstByMach");
|
|
string redKey = fluxLogFirstMaccHash(idxMacchina);
|
|
try
|
|
{
|
|
DataLayer man = new DataLayer();
|
|
rawData = cMemLayer.getRSV(redKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
var redisResult = JsonConvert.DeserializeObject<List<DateTime>>(rawData);
|
|
resultList = redisResult != null ? redisResult : new List<DateTime>();
|
|
}
|
|
else
|
|
{
|
|
resultList = man.taFL
|
|
.getFirstByMacc(idxMacchina, numMax)
|
|
.Select(x => x.dtEvento)
|
|
.ToList();
|
|
// salvo in redis...
|
|
rawData = JsonConvert.SerializeObject(resultList);
|
|
int IO_CacheFluxLogFirstMin = cMemLayer.CRI("IO_CacheFluxLogFirstMin");
|
|
cMemLayer.setRSV(redKey, rawData, IO_CacheFluxLogFirstMin * 60);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero fluxLogFirstByMach{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
resultList = taFL
|
|
.getFirstByMacc(idxMacchina, numMax)
|
|
.Select(x => x.dtEvento)
|
|
.ToList();
|
|
}
|
|
if (resultList == null)
|
|
{
|
|
resultList = new List<DateTime>();
|
|
}
|
|
return resultList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua force Start PODL [CurrProdStatus = 1] se fosse già in essere ODL collegato
|
|
/// --> lascia aperto [CurrProdStatus = 2] se esistesse un ODL da altro PODL x diverso
|
|
/// articolo/fase --> chiude vecchio x poi far partire nuovo [CurrProdStatus = 3] se
|
|
/// fosse chiuso ODL collegato --> duplica PODL e poi avvia nuovo ODL [CurrProdStatus =
|
|
/// 4] se fosse già in essere ODL non collegato --> lascia aperto e collego
|
|
/// </summary>
|
|
/// <param name="idxMacchina">macchina</param>
|
|
/// <param name="CodArt">Codice articolo x PODL da creare</param>
|
|
/// <param name="NumPz">Qty assegnata</param>
|
|
/// <param name="CodGruppo">Codice Gruppo opzionale, default = ND-00</param>
|
|
/// <param name="TCiclo">TCiclo assegnato opzionale, default = 1</param>
|
|
/// <returns></returns>
|
|
public int ForceCreatePOdl(string idxMacchina, string CodArt, int NumPz, string CodGruppo = "ND-00", decimal TCiclo = 1)
|
|
{
|
|
int answ = 0;
|
|
DateTime adesso = DateTime.Now;
|
|
// sistemo codice e descrizione...
|
|
string DescArt = CodArt;
|
|
CodArt = CodArt.Replace(" ", "_");
|
|
// creazione record articolo SE non ci fosse...
|
|
var listArt = taAnagArt.getByCod(CodArt);
|
|
if (listArt == null || listArt.Count == 0)
|
|
{
|
|
// cerco x descrizione...
|
|
listArt = taAnagArt.getByDescr(DescArt);
|
|
// seleziono come codArt il primo trovato...
|
|
if (listArt != null && listArt.Count > 0)
|
|
{
|
|
CodArt = listArt.FirstOrDefault().CodArticolo;
|
|
}
|
|
}
|
|
// ricontrollo se devo creare articolo...
|
|
if (listArt == null || listArt.Count == 0)
|
|
{
|
|
// recupero conf azienda...
|
|
string CodAzienda = "*";
|
|
var listConf = taConfig.GetData();
|
|
var recAzienda = listConf.Where(x => x.chiave.Equals("AZIENDA", StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
|
|
if (recAzienda != null)
|
|
{
|
|
CodAzienda = recAzienda.valore != "*" ? recAzienda.valore : recAzienda.valoreStd;
|
|
}
|
|
taAnagArt.insert(CodArt, DescArt, "", CodArt, "ART", CodAzienda);
|
|
}
|
|
// creazione richiesta
|
|
string keyRich = $"{idxMacchina}-{adesso:yyyyMMdd-HHmmss}";
|
|
taPODL.insertQuery(keyRich, keyRich, true, CodArt, CodGruppo, idxMacchina, NumPz, TCiclo, adesso, 1, 1, "");
|
|
// cerco PODL da chiave...
|
|
var listPOdl = taPODL.getByCodArt(CodArt, true);
|
|
var thisPodl = listPOdl.Where(x => x.KeyRichiesta == keyRich).FirstOrDefault();
|
|
if (thisPodl != null)
|
|
{
|
|
answ = thisPodl.idxPromessa;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua force Start PODL [CurrProdStatus = 1] se fosse già in essere ODL collegato
|
|
/// --> lascia aperto [CurrProdStatus = 2] se esistesse un ODL da altro PODL x diverso
|
|
/// articolo/fase --> chiude vecchio x poi far partire nuovo [CurrProdStatus = 3] se
|
|
/// fosse chiuso ODL collegato --> duplica PODL e poi avvia nuovo ODL [CurrProdStatus =
|
|
/// 4] se fosse già in essere ODL non collegato --> lascia aperto e collego
|
|
/// </summary>
|
|
/// <param name="idxMacchina">macchina</param>
|
|
/// <param name="idxPODL">IDX PODL da processare</param>
|
|
/// <param name="doConfirm">effettuare conferma qty</param>
|
|
/// <param name="matrOpr">effettuare conferma qty</param>
|
|
/// <param name="dtEve">data-ora di avvio (opzionale)</param>
|
|
/// <param name="dtCurr">data-ora attuale (opzionale)</param>
|
|
/// <returns></returns>
|
|
public string ForceStartPOdl(string idxMacchina, int idxPODL, bool doConfirm, int matrOpr = 0, string dtEve = "", string dtCurr = "")
|
|
{
|
|
string answ = "KO";
|
|
int CurrProdStatus = 0;
|
|
string sIdxODL = "";
|
|
// Verifica se evento realtime oppure ho data specificata x processing @dtEve
|
|
DateTime dtEvent = DateTime.Now;
|
|
bool rtimeProc = string.IsNullOrEmpty(dtEve);
|
|
if (!rtimeProc)
|
|
{
|
|
dtEvent = GetSrvDtEvent(dtEve, dtCurr);
|
|
}
|
|
|
|
// verifico NON CI SIA un veto altre chiamate (es split...) - 30 sec di default...
|
|
string redKey = vetoForceStartPOdlMaccHash(idxMacchina);
|
|
string rawData = cMemLayer.getRSV(redKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
Log.Info($"VETO ATTIVO | Richiesto ForceStartPOdl per impianto {idxMacchina} | impossibile procedere");
|
|
}
|
|
else
|
|
{
|
|
// determino veto: se realtime 30sec, altrimenti 1 soltanto
|
|
int vetoTtl = rtimeProc ? 30 : 1;
|
|
// registro VETO x altre chiamate (es split...) 30sec
|
|
cMemLayer.setRSV(redKey, $"Inizio FORCE START PODL: {idxPODL} | realtime: {rtimeProc} | dtEve: {dtEvent}", vetoTtl);
|
|
// calcolo la qta da gestire
|
|
int qtyConf = 0;
|
|
if (doConfirm)
|
|
{
|
|
DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd;
|
|
try
|
|
{
|
|
rigaProd = taPzProd2conf.GetData(idxMacchina)[0];
|
|
qtyConf = rigaProd.pezziNonConfermati;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Errore recupero pezzi da confermare per la macchina {idxMacchina}{Environment.NewLine}{exc}", tipoLog.ERROR);
|
|
}
|
|
}
|
|
|
|
// proseguo
|
|
DS_ProdTempi.ODLDataTable currODLData = null;
|
|
DS_ProdTempi.PromesseODLDataTable reqPODLData = null;
|
|
DS_ProdTempi.ODLRow OdlRow = null;
|
|
DS_ProdTempi.PromesseODLRow POdlRow = null;
|
|
// metodo principale...
|
|
try
|
|
{
|
|
sIdxODL = getCurrODL(idxMacchina);
|
|
// recupero dati da PODL
|
|
reqPODLData = getPODLRowTab(idxPODL);
|
|
// recupero ODL corrente...
|
|
currODLData = currODLRowTab(idxMacchina);
|
|
|
|
// procedo SOLO SE ho trovato un PODL
|
|
if (reqPODLData != null && reqPODLData.Rows.Count > 0)
|
|
{
|
|
POdlRow = reqPODLData[0];
|
|
// prima cosa: verifico se sia un PODL libero (idxODL==0)
|
|
if (reqPODLData[0].IdxODL == 0)
|
|
{
|
|
if (currODLData != null && currODLData.Count > 0)
|
|
{
|
|
OdlRow = currODLData[0];
|
|
// verifico ODL corrente, se compatibili...
|
|
if (OdlRow.CodArticolo == POdlRow.CodArticolo && OdlRow.KeyRichiesta == POdlRow.KeyRichiesta && OdlRow.IdxMacchina == POdlRow.IdxMacchina)
|
|
{
|
|
// compatibili --> caso 4
|
|
CurrProdStatus = 4;
|
|
}
|
|
else
|
|
{
|
|
// anche qui chiusura ed avvio
|
|
CurrProdStatus = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CurrProdStatus = 2;
|
|
}
|
|
}
|
|
// altrimenti se PODL già associato
|
|
else
|
|
{
|
|
// se trovo qualcosa come ODL
|
|
if (currODLData != null && currODLData.Count > 0)
|
|
{
|
|
OdlRow = currODLData[0];
|
|
// se è quello già associato
|
|
if ($"{reqPODLData[0].IdxODL}" == sIdxODL)
|
|
{
|
|
// non devo fare nulla
|
|
CurrProdStatus = 1;
|
|
}
|
|
else
|
|
{
|
|
// altrimenti devo clonare
|
|
CurrProdStatus = 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// anche in questo caso devo clonare PODL
|
|
CurrProdStatus = 3;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Info($"Errore in ForceStartPOdl: non trovato PODL per idxPODL{idxPODL}", tipoLog.ERROR);
|
|
}
|
|
|
|
// OVVIAMENTE solo se ho POdlRow...
|
|
if (POdlRow != null)
|
|
{
|
|
switch (CurrProdStatus)
|
|
{
|
|
case 1:
|
|
// --> non tocco nulla PODL/ODL
|
|
Log.Info($"Richiesto ForceStartPOdl, caso 1 | PODL {idxPODL} | ODL {sIdxODL} | nessun intervento", tipoLog.INFO);
|
|
break;
|
|
|
|
case 2:
|
|
// eventuale chiusura vecchio ODL, 2 sec prima...
|
|
if (currODLData.Count > 0)
|
|
{
|
|
doCloseCurrODL(idxMacchina, doConfirm, qtyConf, currODLData, dtEvent.AddSeconds(-2), matrOpr);
|
|
}
|
|
// avvio PODL: creo nuovo ODL da promessa ed associo
|
|
taODL.inizioSetupPromessa(idxPODL, MatrOpr, POdlRow.IdxMacchina, POdlRow.TCAssegnato, POdlRow.PzPallet, POdlRow.Note, dtEvent);
|
|
// resetto info PODL
|
|
resetPODLData(idxPODL);
|
|
// fix (invio ) dati ODL alla macchina tramite IOB
|
|
Thread.Sleep(200);
|
|
answ = saveOdlData(idxMacchina, currODLData, reqPODLData);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
// eventuale chiusura vecchio ODL
|
|
if (currODLData.Count > 0)
|
|
{
|
|
doCloseCurrODL(idxMacchina, doConfirm, qtyConf, currODLData, dtEvent.AddSeconds(-2), matrOpr);
|
|
}
|
|
// duplico PODL... inserisco nuovo record...
|
|
taPODL.insertQuery(POdlRow.KeyRichiesta, POdlRow.KeyBCode, true, POdlRow.CodArticolo, POdlRow.CodGruppo, POdlRow.IdxMacchina, POdlRow.NumPezzi, POdlRow.TCAssegnato, POdlRow.DueDate, POdlRow.Priorita, POdlRow.PzPallet, POdlRow.Note);
|
|
// recupero PODL attivabili...
|
|
var podlList = taPODL.getByCodArt(POdlRow.CodArticolo, true);
|
|
// cerco quello che ha la stessa fase/macchina e + recente...
|
|
var lastPodl = podlList.Where(x => x.KeyRichiesta == POdlRow.KeyRichiesta && x.IdxMacchina == POdlRow.IdxMacchina).OrderByDescending(x => x.idxPromessa).FirstOrDefault();
|
|
int newPODL = lastPodl != null ? lastPodl.idxPromessa : POdlRow.idxPromessa;
|
|
// avvio (nuovo) PODL
|
|
taODL.inizioSetupPromessa(idxPODL, MatrOpr, POdlRow.IdxMacchina, POdlRow.TCAssegnato, POdlRow.PzPallet, POdlRow.Note, dtEvent);
|
|
// resetto info PODL
|
|
resetPODLData(idxPODL);
|
|
// fix (invio ) dati ODL alla macchina tramite IOB
|
|
Thread.Sleep(200);
|
|
answ = saveOdlData(idxMacchina, currODLData, reqPODLData);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
// eventuale chiusura vecchio ODL, 2 sec prima...
|
|
if (currODLData.Count > 0)
|
|
{
|
|
doCloseCurrODL(idxMacchina, doConfirm, qtyConf, currODLData, dtEvent.AddSeconds(-2), matrOpr);
|
|
}
|
|
// avvio PODL: creo nuovo ODL da promessa ed associo
|
|
taODL.inizioSetupPromessa(idxPODL, MatrOpr, POdlRow.IdxMacchina, POdlRow.TCAssegnato, POdlRow.PzPallet, POdlRow.Note, dtEvent);
|
|
// reseetto info PODL
|
|
resetPODLData(idxPODL);
|
|
// fix (invio ) dati ODL alla macchina tramite IOB
|
|
Thread.Sleep(200);
|
|
answ = saveOdlData(idxMacchina, currODLData, reqPODLData);
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answ = "NF";
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in ForceStartPOdl{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera ArtNum dato CodArt (per impianti che accettano solo INT in scrittura)
|
|
/// </summary>
|
|
/// <param name="CodArt">
|
|
/// CodArt richiesto, se vuoto restituisce TUTTI i valori in tabella di decodifica
|
|
/// </param>
|
|
/// <returns>Dizionario contenente le righe delle codifiche attive Articolo/Numero</returns>
|
|
public Dictionary<string, int> getArtNum(string codArt)
|
|
{
|
|
Dictionary<string, int> answ = new Dictionary<string, int>();
|
|
DS_applicazione.DecNumArticoliDataTable rawData;
|
|
// se vuoto --> leggo tabella
|
|
if (string.IsNullOrEmpty(codArt))
|
|
{
|
|
rawData = taDecNA.GetData();
|
|
}
|
|
// se non vuoto --> chiamo stored x recuperare info
|
|
else
|
|
{
|
|
rawData = taDecNA.getByKey(codArt);
|
|
}
|
|
foreach (var item in rawData)
|
|
{
|
|
answ.Add(item.CodArticolo, item.NumART);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// GET elenco parametri correnti x IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public List<objItem> getCurrObjItems(string idxMacchina)
|
|
{
|
|
string serVal = cMemLayer.getRSV(currParametersHash(idxMacchina));
|
|
List<objItem> actValues = new List<objItem>();
|
|
if (serVal != null)
|
|
{
|
|
try
|
|
{
|
|
var rawVal = JsonConvert.DeserializeObject<List<objItem>>(serVal);
|
|
// ordino!
|
|
actValues = rawVal
|
|
.OrderBy(x => x.displOrdinal)
|
|
.ThenBy(x => x.description)
|
|
.ToList();
|
|
|
|
#if false
|
|
actValues.Sort((a, b) => (a.name.CompareTo(b.name)));
|
|
#endif
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in deserializzazione getCurrObjItems{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return actValues;
|
|
}
|
|
|
|
/// <summary>
|
|
/// GET elenco parametri che richiedono una WRITE x IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public List<objItem> getCurrObjItemsPendigWrite(string idxMacchina)
|
|
{
|
|
string serVal = cMemLayer.getRSV(currParametersHash(idxMacchina));
|
|
List<objItem> actValues = new List<objItem>();
|
|
List<objItem> writeValues = new List<objItem>();
|
|
if (serVal != null)
|
|
{
|
|
try
|
|
{
|
|
actValues = JsonConvert.DeserializeObject<List<objItem>>(serVal);
|
|
// cerco e rimuovo parametri sola lettura o SENZA richieste scrittura
|
|
foreach (var item in actValues)
|
|
{
|
|
if (item.writable && !string.IsNullOrEmpty(item.reqValue))
|
|
{
|
|
writeValues.Add(item);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in deserializzazione getCurrObjItemsPendigWrite{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return writeValues;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce valore dell'ODL attivo (iniziato e NON concluso)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string getCurrODL(string idxMacchina)
|
|
{
|
|
string answ = "";
|
|
// recupero con stored NUOVA...
|
|
DS_ProdTempi.ODLDataTable tabOdl = taODL.getByMacchina(idxMacchina);
|
|
if (tabOdl.Rows.Count > 0)
|
|
{
|
|
// solo SE ho idxODL (altrimenti loggo errore)
|
|
if (tabOdl[0].IdxODL > 0)
|
|
{
|
|
answ = tabOdl[0].IdxODL.ToString();
|
|
answ = answ == "" ? "0" : answ;
|
|
}
|
|
else
|
|
{
|
|
answ = "0";
|
|
Log.Info("[currODL] Errore in currODL x idxMacchina " + idxMacchina + ": IdxODL = 0");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// se è empty --> 0!!!
|
|
answ = "0";
|
|
}
|
|
// ultimo controllo su idxOdl...
|
|
answ = answ == "" ? "0" : answ;
|
|
// restituisco!
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dati deroga SchedaTecnica serializzati in REDIS (get/set)
|
|
/// </summary>
|
|
public StCheckOverride getDerogaSt(int idxST)
|
|
{
|
|
StCheckOverride answ = new StCheckOverride() { IdxST = idxST };
|
|
string keyDerogaST = cMemLayer.redHash($"DerogaSt:{user_std.UtSn.utente}:{idxST:000}");
|
|
string rawData = cMemLayer.getRSV(keyDerogaST);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
try
|
|
{
|
|
answ = JsonConvert.DeserializeObject<StCheckOverride>(rawData);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce una tabella con tutte le transizioni degli ingressi per una data macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public DS_applicazione.TransizioneIngressiDataTable getMatriceIngressi(string idxMacchina)
|
|
{
|
|
DS_applicazione.TransizioneIngressiDataTable answ;
|
|
try
|
|
{
|
|
answ = taTranIngr.getMatriceByIdxMacchina(idxMacchina);
|
|
}
|
|
catch
|
|
{
|
|
answ = null;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera (da DB) i dati della State Machine multi ingressi nel formato
|
|
/// key: IdxMacchina
|
|
/// value: IdxFamigliaIngresso
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public KeyValuePair<string, string>[] getMSMI_DB(string idxMacchina)
|
|
{
|
|
DS_applicazione.MSFDDataTable tabMSMI = new DS_applicazione.MSFDDataTable();
|
|
// 2017.09.13: inserisco gestione singleton condizionale
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
tabMSMI = connDb.taMSFD.getMulti(idxMacchina);
|
|
}
|
|
else
|
|
{
|
|
// leggo DB da singleton
|
|
tabMSMI = MapoDbObj.taMSFD.getMulti(idxMacchina);
|
|
}
|
|
KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[tabMSMI.Count];
|
|
// salvo tutti i valori StateMachineIngressi...
|
|
int i = 0;
|
|
foreach (var item in tabMSMI)
|
|
{
|
|
answ[i] = new KeyValuePair<string, string>(item.IdxMacchina, item.IdxFamigliaIngresso.ToString());
|
|
i++;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore dell'intera RIGA PODL data chiave (da redis o da DB se non trovata...)
|
|
/// </summary>
|
|
/// <param name="idxPODL">IDX della PODL</param>
|
|
/// <returns></returns>
|
|
public DS_ProdTempi.PromesseODLDataTable getPODLRowTab(int idxPODL)
|
|
{
|
|
DS_ProdTempi.PromesseODLDataTable answTab = null;
|
|
string rCall = "";
|
|
string rKey = getPOdlRowHash(idxPODL);
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("hasPODL_row");
|
|
try
|
|
{
|
|
rCall = cMemLayer.getRSV(rKey);
|
|
if (!string.IsNullOrEmpty(rCall))
|
|
{
|
|
answTab = JsonConvert.DeserializeObject<DS_ProdTempi.PromesseODLDataTable>(rCall);
|
|
}
|
|
if (answTab == null || answTab.Count == 0)
|
|
{
|
|
answTab = taPODL.getByKey(idxPODL);
|
|
|
|
// salvo in redis...
|
|
rCall = JsonConvert.SerializeObject(answTab);
|
|
int currOdlRowCacheDur = cMemLayer.CRI("currOdlRowCacheDur");
|
|
cMemLayer.setRSV(rKey, rCall, currOdlRowCacheDur);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in recupero getPODLRowTab{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answTab = taPODL.getByKey(idxPODL);
|
|
}
|
|
return answTab;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua calcolo data-ora di riferimento per il server a poartire da
|
|
/// </summary>
|
|
/// <param name="dtEve"></param>
|
|
/// <param name="dtCurr"></param>
|
|
/// <returns></returns>
|
|
public DateTime GetSrvDtEvent(string dtEve, string dtCurr)
|
|
{
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
// 2017.09.14 trimmo eventualmente lo zero finale dalle date SE supera i millisecondi...
|
|
dtEve = dtEve.Length > 17 ? dtEve.Substring(0, 17) : dtEve;
|
|
dtCurr = dtCurr.Length > 17 ? dtCurr.Substring(0, 17) : dtCurr;
|
|
DateTime dtEvento, dtCorrente;
|
|
// controllo: se ho valori dt x evento e orario DIVERSI per acquisitore IOB calcolo
|
|
// dataOraEvento corretto
|
|
if (dtEve != dtCurr)
|
|
{
|
|
Int64 delta = 0;
|
|
try
|
|
{
|
|
// se ho meno decimali x evento rispetto dtCorrente...
|
|
if (dtEve.Length < dtCurr.Length)
|
|
{
|
|
dtEve = dtEve.PadRight(dtCurr.Length, '0');
|
|
}
|
|
delta = Convert.ToInt64(dtCurr) - Convert.ToInt64(dtEve);
|
|
// se meno di 60'000 ms ...
|
|
if (delta < 59999)
|
|
{
|
|
dataOraEvento = dataOraEvento.AddMilliseconds(-delta);
|
|
}
|
|
else
|
|
{
|
|
// in questo caso elimino i MS dalle stringhe e converto i datetime....
|
|
CultureInfo provider = CultureInfo.InvariantCulture;
|
|
string format = "yyyyMMddHHmmssfff";
|
|
dtEvento = DateTime.ParseExact(dtEve, format, provider);
|
|
dtCorrente = DateTime.ParseExact(dtCurr, format, provider);
|
|
TimeSpan deltaTS = dtCorrente.Subtract(dtEvento);
|
|
dataOraEvento = dataOraEvento.Add(-deltaTS);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"getSrvDtEvent | Errore calcolo ms evento/ora corrente da device remoto:{Environment.NewLine}" +
|
|
$"dtEve : {dtEve}{Environment.NewLine}" +
|
|
$"dtCurr: {dtCurr}{Environment.NewLine}" +
|
|
$"{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
|
|
return dataOraEvento;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce il TempoCiclo effettivo (tecnico) della macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public decimal getTcEffMacchina(string idxMacchina)
|
|
{
|
|
decimal tc = 0;
|
|
try
|
|
{
|
|
DS_ProdTempi.stp_repDonati_getDatiProdMacchinaPeriodoRow riga = taDatiProdMacchPer.GetData(idxMacchina, DateTime.Now.AddMinutes(-30), DateTime.Now)[0];
|
|
if (riga.TCEffRT > 0)
|
|
{
|
|
tc = riga.TCEffRT;
|
|
}
|
|
else
|
|
{
|
|
tc = riga.TCAssegnato;
|
|
}
|
|
}
|
|
catch { }
|
|
// imposto a 99'TC
|
|
if (tc == 0)
|
|
{
|
|
tc = 99.9M;
|
|
// scrivo log per indicare mancato caricamento dati tc dichiarato e conseguente
|
|
// errore sul timer - 2/11/2012 EN&CV
|
|
Log.Info(string.Format("Impostato TC Tempo Ciclo a 99' (99.9M) causa mancato inserimento tempo ciclo dichiarato"));
|
|
}
|
|
return tc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore booleano se la macchina sia abilitata all'input
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool insEnab(string idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("insEnabled");
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(mDatiMacchinaVal(idxMacchina, "insEnabled"));
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
answ = connDb.insEnabled(idxMacchina);
|
|
}
|
|
else
|
|
{
|
|
// leggo DB da singleton
|
|
answ = MapoDbObj.insEnabled(idxMacchina);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore booleano se la macchina sia di tipo MASTER (imposta ODL x gli slave)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool isMaster(string idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("isMaster");
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(mDatiMacchinaVal(idxMacchina, "Master") == "1");
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
answ = MapoDbObj.isMaster(idxMacchina);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore booleano se la macchina sia di tipo MULTI (con più state machine x INGRESSI)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool isMulti(string idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("isMulti");
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(mDatiMacchinaVal(idxMacchina, "Multi") == "1");
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
answ = MapoDbObj.isMulti(idxMacchina);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore booleano se la macchina sia di tipo SLAVE (ODL impostato da MASTER)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool isSlave(string idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("isSlave");
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(mDatiMacchinaVal(idxMacchina, "Slave") == "1");
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
answ = MapoDbObj.isSlave(idxMacchina);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce valore di una singola chiave del dizionario DatiMacchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public string mDatiMacchinaVal(string idxMacchina, string chiave)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = mDatiMacchine(idxMacchina)[chiave];
|
|
}
|
|
catch { }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restitusice elenco KVP dei campi DatiMacchine + StatoMacchine per l'impianto indicato
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public Dictionary<string, string> mDatiMacchine(string idxMacchina)
|
|
{
|
|
// hard coded dimensione vettore DatiMacchine
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
// ORA recupero da memoria redis...
|
|
try
|
|
{
|
|
string currHash = dtMaccHash(idxMacchina);
|
|
answ = cMemLayer.redGetHashDict(currHash);
|
|
// se è vuoto... leggo da DB e popolo!
|
|
if (answ.Count == 0)
|
|
{
|
|
answ = resetDatiMacchina(idxMacchina);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in compilazione dati Macchine x Redis - idxMacchina {2}:{0}{1}", Environment.NewLine, exc, idxMacchina));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restitusice elenco KVP dei TASK (da passare a IOB-WIN) per l'impianto indicato
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public Dictionary<string, string> mOptParMacchina(string idxMacchina)
|
|
{
|
|
// hard coded dimensione vettore DatiMacchine
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
// ORA recupero da memoria redis...
|
|
try
|
|
{
|
|
string currHash = optParHash(idxMacchina);
|
|
answ = cMemLayer.redGetHashDict(currHash);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in compilazione dati OPT PARAM x Redis - idxMacchina {2}:{0}{1}", Environment.NewLine, exc, idxMacchina));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restitusice elenco KVP dei TASK SALVATI (da passare a IOB-WIN) per l'impianto indicato
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public Dictionary<string, string> mSavedTaskMacchina(string idxMacchina)
|
|
{
|
|
// hard coded dimensione vettore DatiMacchine
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
// ORA recupero da memoria redis...
|
|
try
|
|
{
|
|
string currHash = savedTaskHash(idxMacchina);
|
|
answ = cMemLayer.redGetHashDict(currHash);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Errore in recupero dati SAVED TASK x Redis mSavedTaskMacchina | idxMacchina {idxMacchina}{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restitusice elenco KVP
|
|
/// key: IdxMacchina
|
|
/// value: IdxFamigliaIngresso
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public KeyValuePair<string, string>[] mTabMSMI(string idxMacchina)
|
|
{
|
|
// hard coded dimensione vettore DatiMacchine
|
|
KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
|
|
// iniziualizzo con un valore... 0/0
|
|
answ[0] = new KeyValuePair<string, string>("0", "0");
|
|
// ORA recupero da memoria redis...
|
|
try
|
|
{
|
|
string currHash = hMSMI(idxMacchina);
|
|
answ = cMemLayer.redGetHash(currHash);
|
|
// se è vuoto... leggo da DB e popolo!
|
|
if (answ.Length == 0)
|
|
{
|
|
answ = resetMSMI(idxMacchina);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in compilazione Tabella Multi State Machine Ingressi x Redis:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restitusice elenco KVP dei campi della State Machine ingressi nel formato
|
|
/// key: cState_nVal (current MICRO-STATE + "_" + new Value)
|
|
/// value: iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE
|
|
/// </summary>
|
|
/// <param name="idxFamIn"></param>
|
|
/// <returns></returns>
|
|
public KeyValuePair<string, string>[] mTabSMI(int idxFamIn)
|
|
{
|
|
// hard coded dimensione vettore DatiMacchine
|
|
KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
|
|
// iniziualizzo con un valore... 0/0
|
|
answ[0] = new KeyValuePair<string, string>("0", "0");
|
|
// ORA recupero da memoria redis...
|
|
try
|
|
{
|
|
string currHash = hSMI(idxFamIn);
|
|
answ = cMemLayer.redGetHash(currHash);
|
|
// se è vuoto... leggo da DB e popolo!
|
|
if (answ.Length == 0)
|
|
{
|
|
answ = resetSMI(idxFamIn);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in compilazione State Machine Ingressi x Redis:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restitusice elenco KVP dei TASK (da passare a IOB-WIN) per l'impianto indicato
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public Dictionary<string, string> mTaskMacchina(string idxMacchina)
|
|
{
|
|
// hard coded dimensione vettore DatiMacchine
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
// ORA recupero da memoria redis...
|
|
try
|
|
{
|
|
string currHash = exeTaskHash(idxMacchina);
|
|
answ = cMemLayer.redGetHashDict(currHash);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in recupero dati EXE TASK x Redis mTaskMacchina - idxMacchina {2}:{0}{1}", Environment.NewLine, exc, idxMacchina));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione FL da IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="flux"></param>
|
|
/// <param name="valore"></param>
|
|
/// <param name="dtEve"></param>
|
|
/// <param name="dtCurr"></param>
|
|
/// <param name="contatore"></param>
|
|
/// <param name="disabKA"></param>
|
|
/// <returns></returns>
|
|
public string processFluxLog(string idxMacchina, string flux, string valore, string dtEve, string dtCurr, int contatore, bool disabKA)
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
// se non vietato...
|
|
if (!disabKA)
|
|
{
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
connDb.scriviKeepAlive(idxMacchina, DateTime.Now);
|
|
}
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("processFluxLog");
|
|
}
|
|
string answ = "";
|
|
DateTime dataOraEvento = GetSrvDtEvent(dtEve, dtCurr);
|
|
// inizio processing vero e proprio INPUT...
|
|
if (idxMacchina != null && valore != null)
|
|
{
|
|
if (idxMacchina != "" && valore != "")
|
|
{
|
|
// 2020.01.31 nuovo OBJ
|
|
DataLayer man = new DataLayer();
|
|
man.taFL.InsNew(idxMacchina, dataOraEvento, flux, valore, contatore);
|
|
// 2022.06.06 salvo su redis il valore ULTIMO del flux x recupero rapido ultimo valore
|
|
string key = DataLayer.LiveFLogKeyHash(idxMacchina, flux);
|
|
// 10 min cache max...
|
|
int ttlFlog = 60 * 10;
|
|
cMemLayer.setRSV(key, valore, ttlFlog);
|
|
// registro in risposta che è andato tutto bene...
|
|
answ = "OK";
|
|
}
|
|
else
|
|
{
|
|
string errore = "processFluxLog | Errore: parametri macchina/valore vuoti";
|
|
Log.Info(errore, tipoLog.INFO);
|
|
answ = errore;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "processFluxLog | Errore: mancano parametri macchina/valore";
|
|
Log.Info(errore, tipoLog.INFO);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa input da IOB eventualmente registrando i segnali inviati
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="valore"></param>
|
|
/// <param name="dtEve"></param>
|
|
/// <param name="dtCurr"></param>
|
|
/// <param name="contatore"></param>
|
|
/// <returns></returns>
|
|
public string processInput(string idxMacchina, string valore, string dtEve, string dtCurr, string contatore)
|
|
{
|
|
string answ = "";
|
|
// 2018.10.26 controllo dtEve e dtCurr
|
|
if (dtEve == null || dtCurr == null)
|
|
{
|
|
Log.Info(string.Format("procInput: valori nulli date: idxMacchina: {0} | valore: {1} | dtEve: {2} | dtCurr:{3}", idxMacchina, valore, dtEve, dtCurr));
|
|
}
|
|
else if (dtEve.Length < 17 || dtCurr.Length < 17)
|
|
{
|
|
Log.Info(string.Format("procInput: valori data non corretti: idxMacchina: {0} | valore: {1} | dtEve: {2} | dtCurr:{3}", idxMacchina, valore, dtEve, dtCurr));
|
|
}
|
|
else
|
|
{
|
|
// 2017.09.14 trimmo eventualmente lo zero finale dalle date SE supera i millisecondi...
|
|
dtEve = dtEve.Length > 17 ? dtEve.Substring(0, 17) : dtEve;
|
|
dtCurr = dtCurr.Length > 17 ? dtCurr.Substring(0, 17) : dtCurr;
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("processInput");
|
|
}
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
DateTime dtEvento, dtCorrente;
|
|
// controllo: se ho valori dt x evento e orario DIVERSI per acquisitore IOB calcolo
|
|
// dataOraEvento corretto
|
|
if (dtEve != dtCurr)
|
|
{
|
|
// delta è un calcolo MOLTO approssimativo della differenza temporale...
|
|
Int64 delta = 0;
|
|
try
|
|
{
|
|
// se ho meno decimali x evento rispetto dtCorrente...
|
|
if (dtEve.Length < dtCurr.Length)
|
|
{
|
|
Log.Info(string.Format("processInput: fix valore dtEve: {0} vs dtCurr: {1}", dtEve, dtCurr), tipoLog.INFO);
|
|
dtEve = dtEve.PadRight(dtCurr.Length, '0');
|
|
}
|
|
delta = Convert.ToInt64(dtCurr) - Convert.ToInt64(dtEve);
|
|
// log della classe del delta (1-10, 10-100, 100-1k, 1k-10k, > 10k ms)
|
|
string deltaClass = "";
|
|
// faccio SEMPRE calcolo esatto sennò sbaglia...
|
|
CultureInfo provider = CultureInfo.InvariantCulture;
|
|
string format = "yyyyMMddHHmmssfff";
|
|
dtEvento = DateTime.ParseExact(dtEve, format, provider);
|
|
dtCorrente = DateTime.ParseExact(dtCurr, format, provider);
|
|
Int64 tiks = dtCorrente.Ticks - dtEvento.Ticks;
|
|
TimeSpan ts = new TimeSpan(tiks);
|
|
double ms = Math.Abs(ts.TotalMilliseconds);
|
|
// calcolo ESATTO dataora evento
|
|
dataOraEvento = dataOraEvento.AddTicks(-tiks);
|
|
if (ms <= 10)
|
|
{
|
|
deltaClass = "delta 0-10 ms";
|
|
}
|
|
else if (ms <= 100)
|
|
{
|
|
deltaClass = "delta 10-100 ms";
|
|
}
|
|
else if (ms <= 1000)
|
|
{
|
|
deltaClass = "delta 100-1000 ms";
|
|
}
|
|
else if (ms <= 10000)
|
|
{
|
|
deltaClass = "delta 1-10 sec";
|
|
}
|
|
else
|
|
{
|
|
deltaClass = "delta > 10 sec";
|
|
}
|
|
// se ho deltaClass loggo
|
|
if (deltaClass != "")
|
|
{
|
|
Log.Info("Correzione " + deltaClass);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore calcolo ms evento/ora corrente da device remoto:{0}dtEve : {1}{0}dtCurr: {2}{0}{3}", Environment.NewLine, dtEve, dtCurr, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
// inizio processing vero e proprio INPUT...
|
|
if (idxMacchina != null && valore != null)
|
|
{
|
|
if (idxMacchina != "" && valore != "")
|
|
{
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la
|
|
// gestione NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
// se abilitato registro evento sul DB
|
|
if (idxMacchina != "" && sLogEnab(idxMacchina))
|
|
{
|
|
saveSigLog(idxMacchina, valore, dataOraEvento, contatore);
|
|
}
|
|
// continuo col resto
|
|
try
|
|
{
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
connDb.scriviKeepAlive(idxMacchina, DateTime.Now);
|
|
// verifico se sia una macchina MULTI ed in tal caso calcolo i
|
|
// SUB-systems e CHIAMERO' alla fine pure loro....
|
|
if (isMulti(idxMacchina))
|
|
{
|
|
// inizio preprocessing
|
|
string newVal = "";
|
|
// processo OGNI macchina a stati dell'impianto... (KEY:
|
|
// IdxMacchina / IdxMacchina#qualcosa, Val = IdxFamIn)
|
|
foreach (var item in mTabMSMI(idxMacchina))
|
|
{
|
|
newVal = preProcInput(item.Key, valore);
|
|
// ora processo e salvo il valore del microstato...
|
|
// INTERNAMENTE gestisce i casi DB/REDIS secondo necessità
|
|
checkMicroStato(item.Key, newVal, dataOraEvento, contatore);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// ora processo e salvo il valore del microstato... INTERNAMENTE
|
|
// gestisce i casi DB/REDIS secondo necessità
|
|
checkMicroStato(idxMacchina, valore, dataOraEvento, contatore);
|
|
}
|
|
// registro in risposta che è andato tutto bene...
|
|
answ = "OK";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
if (cMemLayer.CRI("_logLevel") > 5)
|
|
{
|
|
string errore = string.Format("Errore: {0}{1}", Environment.NewLine, exc);
|
|
Log.Info(errore, tipoLog.EXCEPTION);
|
|
answ = errore;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// se abilitato registro evento sul DB
|
|
if (idxMacchina != "" && MapoDbObj.sLogEnabled(idxMacchina))
|
|
{
|
|
saveSigLog(idxMacchina, valore, dataOraEvento, contatore);
|
|
}
|
|
// continuo col resto
|
|
try
|
|
{
|
|
// scrivo keep alive!!! (se encessario, altrimenti è in cache...)
|
|
MapoDbObj.scriviKeepAlive(idxMacchina, DateTime.Now);
|
|
// verifico se sia una macchina MULTI ed in tal caso calcolo i
|
|
// SUB-systems e CHIAMERO' alla fine pure loro....
|
|
if (MapoDbObj.isMulti(idxMacchina))
|
|
{
|
|
// inizio preprocessing
|
|
string newVal = "";
|
|
// processo OGNI macchina a stati dell'impianto... (KEY:
|
|
// IdxMacchina / IdxMacchina#qualcosa, Val = IdxFamIn)
|
|
foreach (var item in getMSMI_DB(idxMacchina))
|
|
{
|
|
newVal = preProcInput(item.Key, valore);
|
|
// ora processo e salvo il valore del microstato...
|
|
checkMicroStato(item.Key, newVal, dataOraEvento, contatore);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// ora processo e salvo il valore del microstato...
|
|
checkMicroStato(idxMacchina, valore, dataOraEvento, contatore);
|
|
}
|
|
answ = "OK"; // registro in risposta che è andato tutto bene...
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
if (cMemLayer.CRI("_logLevel") > 5)
|
|
{
|
|
string errore = string.Format("Errore: {0}{1}", Environment.NewLine, exc);
|
|
Log.Info(errore, tipoLog.EXCEPTION);
|
|
answ = errore;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: parametri macchina/valore vuoti";
|
|
Log.Info(errore, tipoLog.INFO);
|
|
answ = errore;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: mancano parametri macchina/valore";
|
|
Log.Info(errore, tipoLog.INFO);
|
|
answ = errore;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione di uno stream di dati LIVE da IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="liveData">Dati live nel formato di lista di KVP chiave/valore1</param>
|
|
/// <returns></returns>
|
|
public string processLiveJson(string idxMacchina, liveIOB liveData)
|
|
{
|
|
if (liveData == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(liveData));
|
|
}
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("processLiveJson");
|
|
}
|
|
string answ = "";
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
// inizio processing vero e proprio INPUT...
|
|
if (!string.IsNullOrEmpty(idxMacchina) && liveData != null)
|
|
{
|
|
// SE ho dei segnali...
|
|
if (liveData.dataList.Count > 0)
|
|
{
|
|
// salvo in Redis nell'area CURR_VAL TUTTI i valori live
|
|
cMemLayer.redSaveHashList(LiveCurrValHash(idxMacchina), liveData.dataList);
|
|
// accodo in buffer ULTIMI valori con dataora uno ad uno...
|
|
KeyValuePair<string, string>[] newData = new KeyValuePair<string, string>[1];
|
|
foreach (var item in liveData.dataList)
|
|
{
|
|
// accodo update valori...
|
|
newData[0] = new KeyValuePair<string, string>(dataOraEvento.ToString(), item.Value);
|
|
cMemLayer.redSaveHash(LiveBufferHash(idxMacchina, item.Key), newData);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: formato liveData errato (split #)";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
// registro in risposta che è andato tutto bene...
|
|
answ = "OK";
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: mancano parametri macchina/liveData come Json";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione di uno stream di dati LIVE da IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="liveData">Dati live nel formato chiave1|valore1#chiave2|valore2#chiave3|valore3</param>
|
|
/// <returns></returns>
|
|
public string processLiveRec(string idxMacchina, string liveData)
|
|
{
|
|
if (liveData == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(liveData));
|
|
}
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("processLiveRec");
|
|
}
|
|
string answ = "";
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
// inizio processing vero e proprio INPUT...
|
|
if (idxMacchina != null && liveData != null)
|
|
{
|
|
if (idxMacchina != "" && liveData != "")
|
|
{
|
|
// prendo il vettore LiveData e lo splitto per variabili inviate
|
|
string[] liveSignals = liveData.Split('|');
|
|
// SE ho dei segnali...
|
|
if (liveSignals.Length > 0)
|
|
{
|
|
KeyValuePair<string, string>[] liveSet = new KeyValuePair<string, string>[liveSignals.Length];
|
|
string[] kvp;
|
|
int i = 0;
|
|
foreach (string liveKVP in liveSignals)
|
|
{
|
|
// ogni variabile la splitto come chiave/valore
|
|
kvp = liveKVP.Split(':');
|
|
liveSet[i] = new KeyValuePair<string, string>(kvp[0], kvp[1]);
|
|
i++;
|
|
}
|
|
// salvo in Redis nell'area CURR_VAL TUTTI i valori live
|
|
cMemLayer.redSaveHash(LiveCurrValHash(idxMacchina), liveSet);
|
|
// accodo in buffer ULTIMI valori con dataora uno ad uno...
|
|
KeyValuePair<string, string>[] newData = new KeyValuePair<string, string>[1];
|
|
foreach (var item in liveSet)
|
|
{
|
|
// accodo update valori...
|
|
newData[0] = new KeyValuePair<string, string>(dataOraEvento.ToString(), item.Value);
|
|
cMemLayer.redSaveHash(LiveBufferHash(idxMacchina, item.Key), newData);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: formato liveData errato (split #)";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
// registro in risposta che è andato tutto bene...
|
|
answ = "OK";
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: parametri macchina/liveData vuoti";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: mancano parametri macchina/liveData";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione UserLog da IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina">Macchina</param>
|
|
/// <param name="flux">Flusso: DI/RC/RC</param>
|
|
/// <param name="valore">valore = note/valString</param>
|
|
/// <param name="dtEve">data evento</param>
|
|
/// <param name="dtCurr">data corrente</param>
|
|
/// <param name="contatore">contatore invio</param>
|
|
/// <param name="matrOpr">Matricola Operatore</param>
|
|
/// <param name="label">label = causale scarto / tagCode</param>
|
|
/// <param name="valNum">valNum = esitoOk (0/1) / Quantità di scarto associata</param>
|
|
/// <returns></returns>
|
|
public string processUserLog(string idxMacchina, string flux, string valore, string dtEve, string dtCurr, int contatore, int matrOpr, string label, int valNum)
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
connDb.scriviKeepAlive(idxMacchina, DateTime.Now);
|
|
// 2017.09.14 trimmo eventualmente lo zero finale dalle date SE supera i millisecondi...
|
|
dtEve = dtEve.Length > 17 ? dtEve.Substring(0, 17) : dtEve;
|
|
dtCurr = dtCurr.Length > 17 ? dtCurr.Substring(0, 17) : dtCurr;
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("processUserLog");
|
|
}
|
|
string answ = "";
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
DateTime dtEvento, dtCorrente;
|
|
// controllo: se ho valori dt x evento e orario DIVERSI per acquisitore IOB calcolo
|
|
// dataOraEvento corretto
|
|
if (dtEve != dtCurr)
|
|
{
|
|
Int64 delta = 0;
|
|
try
|
|
{
|
|
// se ho meno decimali x evento rispetto dtCorrente...
|
|
if (dtEve.Length < dtCurr.Length)
|
|
{
|
|
dtEve = dtEve.PadRight(dtCurr.Length, '0');
|
|
}
|
|
delta = Convert.ToInt64(dtCurr) - Convert.ToInt64(dtEve);
|
|
// se meno di 60'000 ms ...
|
|
if (delta < 59999)
|
|
{
|
|
dataOraEvento = dataOraEvento.AddMilliseconds(-delta);
|
|
}
|
|
else
|
|
{
|
|
// in questo caso elimino i MS dalle stringhe e converto i datetime....
|
|
CultureInfo provider = CultureInfo.InvariantCulture;
|
|
string format = "yyyyMMddHHmmssfff";
|
|
dtEvento = DateTime.ParseExact(dtEve, format, provider);
|
|
dtCorrente = DateTime.ParseExact(dtCurr, format, provider);
|
|
Int64 tiks = dtCorrente.Ticks - dtEvento.Ticks;
|
|
dataOraEvento = dataOraEvento.AddTicks(-tiks);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("processUserLog | Errore calcolo ms evento/ora corrente da device remoto:{0}dtEve : {1}{0}dtCurr: {2}{0}{3}", Environment.NewLine, dtEve, dtCurr, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
// inizio processing vero e proprio INPUT...
|
|
if (string.IsNullOrEmpty(idxMacchina))
|
|
{
|
|
string errore = "processUserLog | Errore: macchina mancante";
|
|
Log.Info(errore, tipoLog.INFO);
|
|
answ = errore;
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrEmpty(flux))
|
|
{
|
|
string errore = "processUserLog | Errore: parametro flux vuoto";
|
|
Log.Info(errore, tipoLog.INFO);
|
|
answ = errore;
|
|
}
|
|
else
|
|
{
|
|
// 2020.01.31 nuovo OBJ
|
|
DataLayer DLMan = new DataLayer();
|
|
// in base al flusso decido dove e cosa scrivere...
|
|
switch (flux)
|
|
{
|
|
case "DI":
|
|
DLMan.taDiarioDich.insertQuery(label, idxMacchina, dataOraEvento, matrOpr, valore);
|
|
break;
|
|
|
|
case "RC":
|
|
bool esitoOk = valNum != 0;
|
|
DLMan.taRC.insertQuery(idxMacchina, matrOpr, esitoOk, valore, dataOraEvento);
|
|
break;
|
|
|
|
case "RS":
|
|
DLMan.taRS.insertQuery(idxMacchina, dataOraEvento, label, valNum, valore, matrOpr);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
// registro in risposta che è andato tutto bene...
|
|
answ = "OK";
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il contapezzi salvato per la macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public int pzCounter(string idxMacchina)
|
|
{
|
|
int answ = -1;
|
|
string rCall = "";
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("getCounter");
|
|
try
|
|
{
|
|
rCall = cMemLayer.getRSV(pzCountHash(idxMacchina));
|
|
if (rCall != "" && rCall != null)
|
|
{
|
|
int.TryParse(rCall, out answ);
|
|
}
|
|
else
|
|
{
|
|
answ = pzCounterTC(idxMacchina);
|
|
// salvo in redis...
|
|
saveCounter(idxMacchina, answ.ToString());
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il contapezzi come CONTEGGIO da TCRilevati per la macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public int pzCounterTC(string idxMacchina)
|
|
{
|
|
int answ = -1;
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("getCounterTC");
|
|
}
|
|
// variabile x controllo dati recuperati
|
|
DS_ProdTempi.StatoProdDataTable datiProdAct = null;
|
|
bool okDatiProd = false;
|
|
int taSP_ms_ant = cMemLayer.cdvi("taStatoProd_ms_anticipo");
|
|
DateTime dataRif = DateTime.Now.AddMilliseconds(-taSP_ms_ant);
|
|
okDatiProd = getStatoProd(idxMacchina, ref datiProdAct, dataRif);
|
|
// se NON avesse recuperato --> aspetto taSP_ms_ant e poi RICHIAMO procedura...
|
|
int maxTry = 3;
|
|
while (!okDatiProd && maxTry > 0)
|
|
{
|
|
Log.Info(string.Format("[pzCounterTC] Impossibile recuperare dati ODL x idxMacchina {0}", idxMacchina), tipoLog.WARNING);
|
|
// sleep...
|
|
Thread.Sleep(taSP_ms_ant * 2);
|
|
// riprovo lettura...
|
|
okDatiProd = getStatoProd(idxMacchina, ref datiProdAct, dataRif);
|
|
maxTry--;
|
|
}
|
|
|
|
// ora proseguo SE ho trovato i dati...
|
|
if (okDatiProd)
|
|
{
|
|
if (datiProdAct != null)
|
|
{
|
|
if (datiProdAct.Count > 0)
|
|
{
|
|
if (!datiProdAct[0].IsPzTotODLNull())
|
|
{
|
|
// ...a questo punto recupero DAVVERO i dati (o almeno ci provo...)
|
|
try
|
|
{
|
|
// controllo
|
|
answ = datiProdAct[0].PzTotODL;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("[pzCounterTC] Eccezione in recupero PzTotODL x idxMacchina {0}{1}{2}", idxMacchina, Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Info(string.Format("[pzCounterTC] Dati ODL x idxMacchina {0} non recuperati dopo tentativi reiterati...", idxMacchina), tipoLog.WARNING);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// RIMUOVE un PARAMETRO OPZIONALE dall'elenco di quelli salvati
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="taskKey"></param>
|
|
/// <returns></returns>
|
|
public bool remOptPar4Machine(string idxMacchina, string taskKey)
|
|
{
|
|
bool answ = false;
|
|
string currHash = optParHash(idxMacchina);
|
|
try
|
|
{
|
|
// leggo task attuali...
|
|
var currVal = mOptParMacchina(idxMacchina);
|
|
currVal.Remove(taskKey);
|
|
cMemLayer.redDelKey(currHash);
|
|
answ = cMemLayer.redSaveHashDict(currHash, currVal);
|
|
}
|
|
catch { }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// RIMUOVE un task dall'elenco di quelli salvati
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="taskKey"></param>
|
|
/// <returns></returns>
|
|
public bool remTask4Machine(string idxMacchina, taskType taskKey)
|
|
{
|
|
bool answ = false;
|
|
string currHash = exeTaskHash(idxMacchina);
|
|
try
|
|
{
|
|
// leggo task attuali...
|
|
var currTask = mTaskMacchina(idxMacchina);
|
|
currTask.Remove(taskKey.ToString());
|
|
cMemLayer.redDelKey(currHash);
|
|
answ = cMemLayer.redSaveHashDict(currHash, currTask);
|
|
Log.Info($"Task REM - idxMacchina: {idxMacchina} | taskKey: {taskKey.ToString()}");
|
|
}
|
|
catch { }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resetta (rileggendo) i dati della macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public Dictionary<string, string> resetDatiMacchina(string idxMacchina)
|
|
{
|
|
string currHash = dtMaccHash(idxMacchina);
|
|
// inizio con un bel reset...
|
|
cMemLayer.redFlushKey(currHash);
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
DS_applicazione.MSFDDataTable tabMSFD = new DS_applicazione.MSFDDataTable();
|
|
// 2018.01.08 SEMPRE senza singleton: instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
tabMSFD = connDb.taMSFD.getByIdxMacc(idxMacchina);
|
|
bool trovato = false;
|
|
// se ho righe...
|
|
DS_applicazione.MSFDDataTable tab = new DS_applicazione.MSFDDataTable();
|
|
DS_applicazione.MSFDRow rigaMSFD;
|
|
if (tabMSFD.Rows.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
rigaMSFD = tabMSFD[0];
|
|
trovato = true;
|
|
}
|
|
catch
|
|
{
|
|
rigaMSFD = tab.NewMSFDRow();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rigaMSFD = tab.NewMSFDRow();
|
|
}
|
|
if (trovato)
|
|
{
|
|
// ora provo a compilare...
|
|
try
|
|
{
|
|
// salvo 1:1 i valori... STATO
|
|
answ.Add("IdxMicroStato", rigaMSFD.IdxMicroStato.ToString());
|
|
answ.Add("IdxStato", rigaMSFD.IdxStato.ToString());
|
|
answ.Add("CodArticolo", rigaMSFD.CodArticolo);
|
|
answ.Add("insEnabled", rigaMSFD.insEnabled.ToString());
|
|
answ.Add("sLogEnabled", rigaMSFD.sLogEnabled.ToString());
|
|
answ.Add("pallet", rigaMSFD.pallet);
|
|
answ.Add("CodArticolo_A", rigaMSFD.CodArticolo_A);
|
|
answ.Add("CodArticolo_B", rigaMSFD.CodArticolo_B);
|
|
answ.Add("TempoCicloBase", rigaMSFD.TempoCicloBase.ToString());
|
|
answ.Add("PzPalletProd", rigaMSFD.PzPalletProd.ToString());
|
|
answ.Add("MatrOpr", rigaMSFD.MatrOpr.ToString());
|
|
answ.Add("lastVal", rigaMSFD.lastVal);
|
|
answ.Add("TCBase", rigaMSFD.TempoCicloBase.ToString());
|
|
|
|
//...e SETUP
|
|
answ.Add("CodMacc", rigaMSFD.codmacchina);
|
|
answ.Add("IdxFamIn", rigaMSFD.IdxFamigliaIngresso.ToString());
|
|
answ.Add("Multi", rigaMSFD.Multi.ToString());
|
|
answ.Add("BitFilt", rigaMSFD.BitFilt.ToString());
|
|
answ.Add("MaxVal", rigaMSFD.MaxVal.ToString());
|
|
answ.Add("BSR", rigaMSFD.BSR.ToString());
|
|
answ.Add("ExplodeBit", rigaMSFD.ExplodeBit.ToString());
|
|
answ.Add("NumBit", rigaMSFD.NumBit.ToString());
|
|
answ.Add("IdxFamMacc", rigaMSFD.IdxFamiglia.ToString());
|
|
answ.Add("simplePallet", rigaMSFD.simplePallet.ToString());
|
|
answ.Add("palletChange", rigaMSFD.palletChange.ToString());
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in compilazione dati MSFD:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// cerco dati master/slave...
|
|
string isMaster = connDb.taM2S.getByMaster(idxMacchina).Count > 0 ? "1" : "0";
|
|
string isSlave = connDb.taM2S.getBySlave(idxMacchina).Count > 0 ? "1" : "0";
|
|
answ.Add("Master", isMaster);
|
|
answ.Add("Slave", isSlave);
|
|
|
|
// verifico il timeout che cambia a seconda che sia vero o falso insEnabled...
|
|
int tOutShort = cMemLayer.cdvi("TmOut.MS.S");
|
|
int tOutLong = cMemLayer.cdvi("TmOut.MS.L");
|
|
int redDtMacTOut = tOutLong;
|
|
try
|
|
{
|
|
redDtMacTOut = (answ["insEnabled"].ToLower() == "true") ? tOutShort : tOutLong;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in calcolo timeout dati macchina: idxMacchina{idxMacchina} | TShort: {tOutShort} | TLong {tOutLong}{Environment.NewLine}{exc}");
|
|
}
|
|
// salvo in redis!
|
|
cMemLayer.redSaveHashDict(currHash, answ, redDtMacTOut);
|
|
}
|
|
else
|
|
{
|
|
Log.Info("Errore in chiamata stp_MSFD_getMacc (connDb.taMSFD.getByIdxMacc(idxMacchina))");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua reset microstato macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
public void resetMicrostatoMacchina(string idxMacchina)
|
|
{
|
|
// salvo microstato 0...
|
|
DateTime dtEve = DateTime.Now;
|
|
MapoDbObj.taMSM.updateQuery(0, dtEve, "FER", idxMacchina);
|
|
// reset in redis
|
|
resetDatiMacchina(idxMacchina);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resetta (rileggendo) i dati della State Machine multi ingressi nel formato
|
|
/// key: IdxMacchina
|
|
/// value: IdxFamigliaIngresso
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public KeyValuePair<string, string>[] resetMSMI(string idxMacchina)
|
|
{
|
|
string currHash = hMSMI(idxMacchina);
|
|
DS_applicazione.MSFDDataTable tabMSMI = new DS_applicazione.MSFDDataTable();
|
|
// 2017.09.13: inserisco gestione singleton condizionale
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
tabMSMI = connDb.taMSFD.getMulti(idxMacchina);
|
|
}
|
|
else
|
|
{
|
|
// leggo DB da singleton
|
|
tabMSMI = MapoDbObj.taMSFD.getMulti(idxMacchina);
|
|
}
|
|
KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[tabMSMI.Count];
|
|
// salvo tutti i valori StateMachineIngressi...
|
|
int i = 0;
|
|
foreach (var item in tabMSMI)
|
|
{
|
|
answ[i] = new KeyValuePair<string, string>(item.IdxMacchina, item.IdxFamigliaIngresso.ToString());
|
|
i++;
|
|
}
|
|
// verifico il timeout (default 60 sec...)
|
|
int tOut = (cMemLayer.cdvi("TmOut.MSMI") <= 0) ? 60 : cMemLayer.cdvi("TmOut.MSMI");
|
|
// salvo in redis!
|
|
cMemLayer.redSaveHash(currHash, answ, tOut);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resetta (rileggendo) i dati della State Machine ingressi nel formato
|
|
/// key: cState_nVal (current MICRO-STATE + "_" + new Value)
|
|
/// value: iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE)
|
|
/// </summary>
|
|
/// <param name="idxFamIn"></param>
|
|
/// <returns></returns>
|
|
public KeyValuePair<string, string>[] resetSMI(int idxFamIn)
|
|
{
|
|
string currHash = hSMI(idxFamIn);
|
|
DS_applicazione.TransizioneIngressiDataTable tabSMI = new DS_applicazione.TransizioneIngressiDataTable();
|
|
// 2017.09.13: inserisco gestione singleton condizionale
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
tabSMI = connDb.taTransIngr.getByIdxFamIng(idxFamIn);
|
|
}
|
|
else
|
|
{
|
|
// leggo DB da singleton
|
|
tabSMI = MapoDbObj.taTransIngr.getByIdxFamIng(idxFamIn);
|
|
}
|
|
KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[tabSMI.Count];
|
|
// salvo tutti i valori StateMachineIngressi...
|
|
int i = 0;
|
|
string key = "";
|
|
string val = "";
|
|
foreach (var item in tabSMI)
|
|
{
|
|
key = string.Format("{0}_{1}", item.IdxMicroStato, item.ValoreIngresso);
|
|
val = string.Format("{0}_{1}", item.IdxTipoEvento, item.next_IdxMicroStato);
|
|
answ[i] = new KeyValuePair<string, string>(key, val);
|
|
i++;
|
|
}
|
|
// verifico il timeout (default 60 sec...)
|
|
int tOut = (cMemLayer.cdvi("TmOut.SMI") <= 0) ? 60 : cMemLayer.cdvi("TmOut.SMI");
|
|
// salvo in redis!
|
|
cMemLayer.redSaveHash(currHash, answ, tOut);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// rigenera la tab diario di bordo x la macchian richiesta nell'intervallo definito
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="dataInizio"></param>
|
|
/// <param name="dataFine"></param>
|
|
public void rigeneraDiarioDiBordo(string IdxMacchina, DateTime dataInizio, DateTime dataFine)
|
|
{
|
|
// elimino da diario di bordo i valori nell'intervallo...
|
|
MapoDbObj.taDiario.DeleteByMacchinaPeriodo(IdxMacchina, dataInizio, dataFine);
|
|
// seleziono le righe eventi interessate e le processo 1 ad 1...
|
|
DS_applicazione.EventListDataTable tabEventi = MapoDbObj.taEvList.GetByMacchinaPeriodo(IdxMacchina, dataInizio, dataFine);
|
|
foreach (DS_applicazione.EventListRow rigaEv in tabEventi)
|
|
{
|
|
if (rigaEv.IdxTipo <= 12) // è barcode
|
|
{
|
|
checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, rigaEv.InizioStato, rigaEv.IdxTipo, rigaEv.CodArticolo, rigaEv.Value, rigaEv.MatrOpr, rigaEv.pallet);
|
|
}
|
|
else // è hw
|
|
{
|
|
checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, rigaEv.InizioStato, rigaEv.IdxTipo, rigaEv.CodArticolo, rigaEv.Value, rigaEv.MatrOpr, rigaEv.pallet);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione EVENTO CONTEGGIO PEZZI x una data macchina IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina">Macchina</param>
|
|
/// <param name="qty">Pezzi da registrare</param>
|
|
/// <returns></returns>
|
|
public string saveCaricoPezzi(string idxMacchina, string qty)
|
|
{
|
|
// default: 0, non registrato come cautela...
|
|
string answ = "0";
|
|
// controllo per proseguire
|
|
if (!string.IsNullOrEmpty(idxMacchina) && !string.IsNullOrEmpty(qty))
|
|
{
|
|
int numPzIncr = -1;
|
|
int.TryParse(qty, out numPzIncr);
|
|
// se il conteggio è >= 0 SALVO evento...
|
|
if (numPzIncr >= 0)
|
|
{
|
|
// recupero ODL corrente
|
|
var currData = currODLRowTab(idxMacchina);
|
|
// registro evento 120 --> contapezzi in blocco !!!HARD CODED!!! !!!FIXME!!!
|
|
int idxEvento = 120;
|
|
// istanziato un NUOVO oggetto x scrivere...
|
|
scriviRigaEventoBarcode(idxMacchina, idxEvento, currData[0].CodArticolo, qty);
|
|
}
|
|
// registro in risposta che è andato tutto bene... ovvero la qty richiesta...
|
|
answ = qty;
|
|
}
|
|
else
|
|
{
|
|
string errore = $"Errore: mancano parametri macchina/incremento: idxMacchina {idxMacchina} | qty {qty}";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione EVENTO CONTEGGIO PEZZI x una data macchina IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina">Macchina</param>
|
|
/// <param name="qty">Pezzi da registrare</param>
|
|
/// <returns></returns>
|
|
public string saveCaricoPezzi(string idxMacchina, string qty, string dtEve = "", string dtCurr = "")
|
|
{
|
|
// default: 0, non registrato come cautela...
|
|
string answ = "0";
|
|
// Verifica se evento realtime oppure ho data specificata x processing @dtEve
|
|
DateTime adesso = DateTime.Now;
|
|
DateTime dtEvent = adesso;
|
|
bool rtimeProc = string.IsNullOrEmpty(dtEve);
|
|
if (!rtimeProc)
|
|
{
|
|
dtEvent = GetSrvDtEvent(dtEve, dtCurr);
|
|
}
|
|
|
|
// controllo per proseguire
|
|
if (!string.IsNullOrEmpty(idxMacchina) && !string.IsNullOrEmpty(qty))
|
|
{
|
|
int numPzIncr = -1;
|
|
int.TryParse(qty, out numPzIncr);
|
|
// se il conteggio è >= 0 SALVO evento...
|
|
if (numPzIncr >= 0)
|
|
{
|
|
string codArt = "";
|
|
// recupero ODL ALLA DATA.. da evento a 1 sec dopo
|
|
DataLayer man = new DataLayer();
|
|
var listOdl = man.taODL.getByMacchinaPeriodo(idxMacchina, dtEvent, dtEvent.AddSeconds(1));
|
|
if (listOdl != null && listOdl.Count > 0)
|
|
{
|
|
codArt = listOdl.FirstOrDefault().CodArticolo;
|
|
// registro evento 120 --> contapezzi in blocco !!!HARD CODED!!! !!!FIXME!!!
|
|
int idxEvento = 120;
|
|
// istanziato un NUOVO oggetto x scrivere...
|
|
scriviRigaEventoBarcode(idxMacchina, idxEvento, codArt, qty, 0, "", dtEvent, adesso);
|
|
// registro in risposta che è andato tutto bene... ovvero la qty richiesta...
|
|
answ = qty;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = $"Errore: mancano parametri macchina/incremento: idxMacchina {idxMacchina} | qty {qty}";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione di un counter x una data macchina IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="counter">contapezzi</param>
|
|
/// <returns></returns>
|
|
public string saveCounter(string idxMacchina, string counter)
|
|
{
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("saveCounter");
|
|
}
|
|
string answ = "0";
|
|
// inizio processing vero e proprio INPUT...
|
|
if (!string.IsNullOrEmpty(idxMacchina))
|
|
{
|
|
if (!string.IsNullOrEmpty(counter))
|
|
{
|
|
int newCounter = -1;
|
|
int.TryParse(counter, out newCounter);
|
|
// se il conteggio è >= 0 SALVO come nuovo conteggio...
|
|
if (newCounter >= 0)
|
|
{
|
|
string redKey = pzCountHash(idxMacchina);
|
|
// verifico SE ci sia chiave in redis (ALTRIMENTI rileggo da DB)
|
|
string redVal = cMemLayer.getRSV(redKey);
|
|
if (!string.IsNullOrEmpty(redVal))
|
|
{
|
|
// salvo in Redis nell'area corretta il valore richiesto
|
|
cMemLayer.setRSV(redKey, counter);
|
|
// imposto risposta...
|
|
answ = counter;
|
|
}
|
|
else
|
|
{
|
|
// rileggo da DB e salvo e poi restituisco questo...
|
|
int currCount = pzCounterTC(idxMacchina);
|
|
cMemLayer.setRSV(redKey, currCount.ToString());
|
|
// imposto risposta...
|
|
answ = currCount.ToString();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: parametro counter vuoto";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: parametro macchina vuoto";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processa registrazione ODL corrente x macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="currODL">cod ODL in produzione, se "" --> non c'è...</param>
|
|
/// <returns></returns>
|
|
public string saveCurrODL(string idxMacchina, string currODL)
|
|
{
|
|
if (currODL == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(currODL));
|
|
}
|
|
// registro conteggio impiego chiamate REDIS
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("saveCurrODL");
|
|
}
|
|
string answ = "";
|
|
// inizio processing vero e proprio INPUT...
|
|
if (idxMacchina != null && currODL != null)
|
|
{
|
|
if (idxMacchina != "" && currODL != "")
|
|
{
|
|
int currOdlCacheDur = cMemLayer.CRI("currOdlCacheDur");
|
|
// se ODL fosse 0 USO DURATA CACHE 1/4...
|
|
if (currODL == "0")
|
|
{
|
|
currOdlCacheDur = currOdlCacheDur / 4;
|
|
}
|
|
cMemLayer.setRSV(currODLHash(idxMacchina), currODL, currOdlCacheDur);
|
|
// registro in risposta che è andato tutto bene...
|
|
answ = "OK";
|
|
}
|
|
else
|
|
{
|
|
string errore = string.Format("Errore: parametri macchina/currODL vuoti ({0}/{1})", idxMacchina, currODL);
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errore = "Errore: mancano parametri macchina/currODL";
|
|
Log.Info(errore, tipoLog.ERROR);
|
|
answ = errore;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// salva il segnale di "microstato"
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina</param>
|
|
/// <param name="valore">valore ingresso</param>
|
|
/// <param name="dtEve">data-ora evento (server)</param>
|
|
/// <param name="contatore">sequenza dati inviati</param>
|
|
/// <returns></returns>
|
|
public void saveSigLog(string idxMacchina, string valore, DateTime dtEve, string contatore)
|
|
{
|
|
int cont = 0;
|
|
try
|
|
{
|
|
cont = Convert.ToInt32(contatore);
|
|
}
|
|
catch { }
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// 2017.06.09 forzo init x errori "sovrapposizioni"
|
|
taSigLog = new DS_applicazioneTableAdapters.SignalLogTableAdapter();
|
|
}
|
|
taSigLog.Insert(DateTime.Now, idxMacchina, valore, dtEve, cont);
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento nel db
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <param name="eventTime">data-ora dell'evento</param>
|
|
/// <param name="currentTime">data-ora corrente dell'invio</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaEvento(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet, DateTime eventTime, DateTime currentTime)
|
|
{
|
|
int inserito = 0;
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
// 2017.06.09 forzo init x errori "sovrapposizioni"
|
|
MapoDbObj.taEvList = new DS_applicazioneTableAdapters.EventListTableAdapter();
|
|
}
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// calcolo dataOra reale (evento + delta(ora server - ora remota)
|
|
DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
|
|
// inserisco evento
|
|
inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, eventTime, currentTime, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento nel db
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaEvento(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet)
|
|
{
|
|
int inserito = 0;
|
|
// 2017.06.09 forzo init x errori "sovrapposizioni"
|
|
MapoDbObj.taEvList = new DS_applicazioneTableAdapters.EventListTableAdapter();
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
DateTime dataOra = DateTime.Now;
|
|
// inserisco evento
|
|
inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione:{0}{7}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento nel db SENZA passare operatore e pallet (mette a 0 e "-")
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaEvento(string IdxMacchina, int IdxTipo, string CodArticolo, string Value)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
DateTime dataOra = DateTime.Now;
|
|
// inserisco evento
|
|
inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
|
|
}
|
|
catch
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento inviato da Barcode nel db
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <param name="eventTime">data-ora dell'evento</param>
|
|
/// <param name="currentTime">data-ora corrente dell'invio</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet, DateTime eventTime, DateTime currentTime)
|
|
{
|
|
int inserito = 0;
|
|
// calcolo dataOra reale (evento + delta(ora server - ora remota)
|
|
DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, eventTime, currentTime, exc), tipoLog.EXCEPTION);
|
|
}
|
|
try
|
|
{
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in checkCambiaStatoBatch(8) | tipoInputEvento: {tipoInputEvento.barcode} | IdxMacchina: {IdxMacchina} | dataOra: {dataOra} | IdxTipo: {IdxTipo} | CodArticolo: {CodArticolo} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}{Environment.NewLine}{exc}");
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento inviato da Barcode nel db
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet)
|
|
{
|
|
int inserito = 0;
|
|
DateTime dataOra = DateTime.Now;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione: {0}{7}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, exc), tipoLog.EXCEPTION);
|
|
}
|
|
try
|
|
{
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in checkCambiaStatoBatch(6) | tipoInputEvento: {tipoInputEvento.barcode} | IdxMacchina: {IdxMacchina} | dataOra: {dataOra} | IdxTipo: {IdxTipo} | CodArticolo: {CodArticolo} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}{Environment.NewLine}{exc}");
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento inviato da Barcode nel db SENZA operatore e pallet (mette a 0
|
|
/// e "-")
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string CodArticolo, string Value)
|
|
{
|
|
int inserito = 0;
|
|
DateTime dataOra = DateTime.Now;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
|
|
}
|
|
catch
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value), tipoLog.EXCEPTION);
|
|
}
|
|
try
|
|
{
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in checkCambiaStatoBatch(4) | tipoInputEvento: {tipoInputEvento.barcode} | IdxMacchina: {IdxMacchina} | dataOra: {dataOra} | IdxTipo: {IdxTipo} | CodArticolo: {CodArticolo} | Value: {Value} | MatrOpr: 0 | pallet: -{Environment.NewLine}{exc}");
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
public int scriviRigaEventoSimulata(DateTime dataOra, string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet)
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
int inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
|
|
return inserito;
|
|
}
|
|
|
|
public int scriviRigaEventoSimulata(DateTime dataOra, string IdxMacchina, int IdxTipo, string CodArticolo, string Value)
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
int inserito = MapoDbObj.taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
|
|
return inserito;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di stato nel diario di bordo
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxStato">idx stato</param>
|
|
/// <param name="CodArticolo">Codice Articolo</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <param name="eventTime">data-ora dell'evento</param>
|
|
/// <param name="currentTime">data-ora corrente dell'invio</param>
|
|
/// <returns></returns>
|
|
public inputComandoMapo scriviRigaStato(string IdxMacchina, int IdxStato, string CodArticolo, string Value, int MatrOpr, string pallet, DateTime eventTime, DateTime currentTime)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// calcolo dataOra reale (evento + delta(ora server - ora remota)
|
|
DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
|
|
// inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
|
|
inserito = MapoDbObj.taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, CodArticolo, null, null, MatrOpr, pallet);
|
|
}
|
|
catch
|
|
{
|
|
Log.Info(string.Format("Errore in fase di scrittura stato con i seguenti dati:{0} macchina {1}{0} IdxStato {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxStato, CodArticolo, Value, MatrOpr, pallet, eventTime, currentTime), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
public int scriviRigaStatoSimulata(DateTime dataOra, string IdxMacchina, int IdxStato, string CodArticolo, string Value, int MatrOpr, string pallet)
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
|
|
int inserito = MapoDbObj.taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, CodArticolo, null, null, MatrOpr, pallet);
|
|
return inserito;
|
|
}
|
|
|
|
public int scriviRigaStatoSimulata(DateTime dataOra, string IdxMacchina, int IdxStato, string CodArticolo, string Value)
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
|
|
int inserito = MapoDbObj.taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, CodArticolo, null, null, 0, "-");
|
|
return inserito;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invia una mail al destinatario con oggetto e contenuto
|
|
/// </summary>
|
|
/// <param name="destinatario"></param>
|
|
/// <param name="oggetto"></param>
|
|
/// <param name="corpo"></param>
|
|
/// <returns></returns>
|
|
public bool sendEmail(string destinatario, string oggetto, string corpo)
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
// compongo la stringa
|
|
string mittente = cMemLayer.CRS("_fromEmail");
|
|
gestEmail.geAuth.mandaEmail(mittente, destinatario, oggetto, corpo);
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in sendEmail{Environment.NewLine}{exc}", tipoLog.ERROR);
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// invia una mail al destinatario x linkare nuovi devices tramite URL
|
|
/// </summary>
|
|
/// <param name="destinatario"></param>
|
|
/// <param name="UserAuthKey"></param>
|
|
/// <param name="idxDipendente"></param>
|
|
/// <returns></returns>
|
|
public bool sendUserAuthEmail(string destinatario, string UserAuthKey, int idxDipendente)
|
|
{
|
|
bool fatto = false;
|
|
string smtpCli = "";
|
|
string mittente = "";
|
|
string oggetto = "";
|
|
string userUrl = "";
|
|
string baseUrl = "";
|
|
string userWebUrl = "";
|
|
string baseWebUrl = "";
|
|
string corpo = "";
|
|
try
|
|
{
|
|
// compongo la stringa
|
|
smtpCli = cMemLayer.CRS("_smtpCli");
|
|
mittente = cMemLayer.CRS("_fromEmail");
|
|
oggetto = "Link autorizzazione device per GPW";
|
|
baseUrl = cMemLayer.CRS("baseUrl");
|
|
baseWebUrl = cMemLayer.CRS("baseWebUrl");
|
|
userUrl = string.Format("{2}jumper.aspx?UserAuthkey={0}&idxDipendente={1}", UserAuthKey, idxDipendente, baseUrl);
|
|
userWebUrl = string.Format("{2}jumper.aspx?UserAuthkey={0}&idxDipendente={1}", UserAuthKey, idxDipendente, baseWebUrl);
|
|
corpo = string.Format("Hai ricevuto questa email su richiesta tua o dell'Admin per poter procedere a registrare un (nuovo) devices con GPW:{0}<br/>Per proseguire clicca sul link seguente(rete interna):<br />{0}{0}{1}{0}{0}<br /><br />oppure sul link seguente (internet):<br />{0}{0}{2}{0}{0}<br /><br />Team GPW Steamware", Environment.NewLine, userUrl, userWebUrl);
|
|
gestEmail.geAuth.mandaEmail(mittente, destinatario, oggetto, corpo);
|
|
fatto = true;
|
|
}
|
|
catch { }
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invia email di avviso che ci sono dei TC da confermare
|
|
/// </summary>
|
|
/// <param name="destinatario"></param>
|
|
/// <returns></returns>
|
|
public bool sendWarnTcChangeReq(string destinatario)
|
|
{
|
|
bool fatto = false;
|
|
string mittente = "";
|
|
string oggetto = "";
|
|
string pageUrl = "";
|
|
string corpo = "";
|
|
try
|
|
{
|
|
// compongo la stringa
|
|
mittente = cMemLayer.CRS("_fromEmail");
|
|
oggetto = cMemLayer.CRS("oggettoChgTc");
|
|
pageUrl = string.Format("{0}{1}", cMemLayer.CRS("baseUrlAdmin"), cMemLayer.CRS("pageUrlApprODL"));
|
|
corpo = string.Format(cMemLayer.CRS("corpoChgTc"), Environment.NewLine, pageUrl);
|
|
if (cMemLayer.CRB("_useAuthSmtp"))
|
|
{
|
|
gestEmail.geAuth.mandaEmail(mittente, destinatario, oggetto, corpo);
|
|
}
|
|
else
|
|
{
|
|
gestEmail.ge.mandaEmail(mittente, destinatario, oggetto, corpo);
|
|
}
|
|
fatto = true;
|
|
}
|
|
catch { }
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// SET elenco parametri correnti x IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="currValues"></param>
|
|
/// <returns></returns>
|
|
public bool setCurrObjItems(string idxMacchina, List<objItem> currValues)
|
|
{
|
|
bool answ = false;
|
|
if (currValues != null)
|
|
{
|
|
string serVal = JsonConvert.SerializeObject(currValues);
|
|
cMemLayer.setRSV(currParametersHash(idxMacchina), serVal);
|
|
// controllo se ha valori write...
|
|
foreach (var item in currValues)
|
|
{
|
|
// se fosse un valore WRITE e mi ha dato un valore vuoto --> mando un fix x riscrittura
|
|
if (item.writable && (string.IsNullOrEmpty(item.value) || string.IsNullOrEmpty(item.reqValue)))
|
|
{
|
|
Log.Info($"setCurrObjItems | parametro empty | {item.uid} | Value: {item.value} | reqVal: {item.reqValue}");
|
|
// se è un parametro dei "task principali...
|
|
try
|
|
{
|
|
taskType currTask = (taskType)Enum.Parse(typeof(taskType), item.uid);
|
|
string newVal = !string.IsNullOrEmpty(item.reqValue) ? item.reqValue : $"{item.value}";
|
|
addCheckTask4Machine(idxMacchina, currTask, newVal);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in setCurrObjItems in fase di riaccodamento{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
}
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public bool setDerogaSt(StCheckOverride deroga)
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
string keyDerogaST = cMemLayer.redHash($"DerogaSt:{user_std.UtSn.utente}:{deroga.IdxST:000}");
|
|
string rawData = JsonConvert.SerializeObject(deroga);
|
|
cMemLayer.setRSV(keyDerogaST, rawData, 60 * 2);
|
|
fatto = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio YAML completo di configurazione dell'IOB
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="iobConfFull"></param>
|
|
/// <returns></returns>
|
|
public bool setIobConfYaml(string idxMacchina, string iobConfFull)
|
|
{
|
|
bool answ = false;
|
|
// se ho un area memoria valida...
|
|
if (!string.IsNullOrEmpty(iobConfFull))
|
|
{
|
|
// salvo!
|
|
cMemLayer.setRSV(ConfYamlHash(idxMacchina), iobConfFull);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio della mappa di memoria dell'IOB x ulteriori impieghi
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="currMemMap"></param>
|
|
/// <returns></returns>
|
|
public bool setIobMemMap(string idxMacchina, plcMemMap currMemMap)
|
|
{
|
|
bool answ = false;
|
|
// se ho un area memoria valida...
|
|
if (currMemMap != null)
|
|
{
|
|
// salvo!
|
|
string serVal = JsonConvert.SerializeObject(currMemMap);
|
|
cMemLayer.setRSV(memMapHash(idxMacchina), serVal);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore booleano se la macchina sia abilitata all'inserimento COMPLETO nel
|
|
/// Signal Log
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool sLogEnab(string idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
saveCallRec("sLogEnabled");
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(mDatiMacchinaVal(idxMacchina, "sLogEnabled"));
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure dritto su DB
|
|
else
|
|
{
|
|
answ = MapoDbObj.sLogEnabled(idxMacchina);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua chiamata DB x snapshot del FluxLog della macchina richiesta (insieme set ultimi dati)
|
|
/// </summary>
|
|
/// <param name="id">IdxMacchina</param>
|
|
/// <param name="id">
|
|
/// Dimensione della finestra temporale da ultimo record indietro x salvare valori
|
|
/// </param>
|
|
/// <returns></returns>
|
|
public string takeFlogSnapshot(string id, int windSize)
|
|
{
|
|
string answ = "ND";
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
|
|
try
|
|
{
|
|
// ora chiamo la stored di duplicazione
|
|
DataLayer DLMan = new DataLayer();
|
|
DLMan.taFL.takeSnapshot(id, windSize);
|
|
answ = "OK";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"takeFlogSnapshot:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua chiamata DB x snapshot del FluxLog della macchina richiesta (insieme set ultimi dati)
|
|
/// </summary>
|
|
/// <param name="id">IdxMacchina</param>
|
|
/// <param name="dtMin">DT start x effettuare snapshot</param>
|
|
/// <param name="dtMax">DT end x effettuare snapshot</param>
|
|
/// <returns></returns>
|
|
public string takeFlogSnapshotLast(string id, DateTime dtMin, DateTime dtMax)
|
|
{
|
|
string answ = "ND";
|
|
// instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
|
|
try
|
|
{
|
|
// ora chiamo la stored di duplicazione
|
|
DataLayer DLMan = new DataLayer();
|
|
DLMan.taFL.TakeSnapshotLast(id, dtMin, dtMax);
|
|
answ = "OK";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"TakeSnapshotLast:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiornamento parametro per macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="Original_uid">Parametro macchina come definito in file json</param>
|
|
/// <param name="reqValue"></param>
|
|
/// <returns></returns>
|
|
public bool updateMachineParameter(string idxMacchina, string Original_uid, string reqValue)
|
|
{
|
|
bool answ = false;
|
|
// recupero items...
|
|
List<objItem> dcList = getCurrObjItems(idxMacchina);
|
|
List<objItem> list2Update = new List<objItem>();
|
|
// cerco quello da aggiornare
|
|
objItem trovato = dcList.Find(obj => obj.uid == Original_uid);
|
|
// se non trova --> crea ed aggiunge...
|
|
if (trovato == null)
|
|
{
|
|
dcList.Add(new objItem() { uid = Original_uid });
|
|
trovato = dcList.Find(obj => obj.uid == Original_uid);
|
|
}
|
|
|
|
// se trovato procedo
|
|
if (trovato != null)
|
|
{
|
|
// aggiorno valore richiesto + dt richiesta
|
|
trovato.reqValue = reqValue;
|
|
trovato.lastRequest = DateTime.Now;
|
|
list2Update.Add(trovato);
|
|
upsertCurrObjItems(idxMacchina, list2Update);
|
|
|
|
// accodo in task 2 exe la richiesta di processing
|
|
addTask4Machine(idxMacchina, taskType.setParameter, trovato.uid);
|
|
|
|
// salvo ANCHE il valore di setup ASSOCIATO...
|
|
taskType currTask = (taskType)Enum.Parse(typeof(taskType), trovato.uid);
|
|
addTask4Machine(idxMacchina, currTask, reqValue);
|
|
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua UPSERT elenco parametri correnti x IOB (se c'è UPDATE, se manca ADD)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="innovations"></param>
|
|
/// <returns></returns>
|
|
public bool upsertCurrObjItems(string idxMacchina, List<objItem> innovations)
|
|
{
|
|
bool answ = false;
|
|
if (innovations != null)
|
|
{
|
|
Log.Info($"upsertCurrObjItems | idxMacchina: {idxMacchina} | {innovations.Count} innovations");
|
|
// leggo i valori attuali...
|
|
List<objItem> actValues = getCurrObjItems(idxMacchina);
|
|
// per ogni valore passatomi faccio insert o update rispetto elenco valori correnti
|
|
// in REDIS
|
|
foreach (var item in actValues)
|
|
{
|
|
// cerco nelle innovazioni SE CI SIA il valore...
|
|
objItem trovato = innovations.Find(obj => obj.uid == item.uid);
|
|
// se non trovato nelle innovazioni...
|
|
if (trovato == null)
|
|
{
|
|
// lo ri-aggiungo x non perderlo
|
|
innovations.Add(item);
|
|
Log.Trace($"innovations | add | item.uid: {item.uid} | item.value: {item.value}");
|
|
}
|
|
else
|
|
// altrimenti aggiorno campo (non trasmesso) name e tengo il resto...
|
|
{
|
|
trovato.name = item.name;
|
|
Log.Info($"innovations | update | item.uid: {item.uid} | item.value: {item.value} --> {trovato.value} ");
|
|
}
|
|
}
|
|
// serializzo e salvo
|
|
string serVal = JsonConvert.SerializeObject(innovations);
|
|
cMemLayer.setRSV(currParametersHash(idxMacchina), serVal);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce il valore SPECIFICATO per la state machine ingressi
|
|
/// value: iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE)
|
|
/// </summary>
|
|
/// <param name="idxFamIn"></param>
|
|
/// <param name="idxMicroStato"></param>
|
|
/// <param name="valoreIn"></param>
|
|
/// <returns></returns>
|
|
public string valoreSMI(int idxFamIn, int idxMicroStato, int valoreIn)
|
|
{
|
|
string currHash = hSMI(idxFamIn);
|
|
string field = string.Format("{0}_{1}", idxMicroStato, valoreIn);
|
|
return cMemLayer.redGetHashField(currHash, field);
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
/// <summary>
|
|
/// indica conferma con rettifica (evento 121)
|
|
/// </summary>
|
|
protected bool confRett = false;
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// init dei table adapters
|
|
/// </summary>
|
|
protected void initTA()
|
|
{
|
|
// istanzio oggetto
|
|
taAG = new DS_applicazioneTableAdapters.AnagraficaGruppiTableAdapter();
|
|
taAlarmLog = new DS_applicazioneTableAdapters.AlarmLogTableAdapter();
|
|
taAnagArt = new DS_ProdTempiTableAdapters.AnagArticoliTableAdapter();
|
|
taAnagEventi = new DS_applicazioneTableAdapters.AnagraficaEventiTableAdapter();
|
|
taAnagStati = new DS_applicazioneTableAdapters.AnagraficaStatiTableAdapter();
|
|
taAnagTags = new DS_applicazioneTableAdapters.AnagTagsTableAdapter();
|
|
taAs400 = new DS_IntServTableAdapters.ProduzioneAs400TableAdapter();
|
|
taArcaGiac = new DS_ArcaTableAdapters.GiacenzeTableAdapter();
|
|
taDecNA = new DS_applicazioneTableAdapters.DecNumArticoliTableAdapter();
|
|
taCalFF = new DS_ProdTempiTableAdapters.CalendFesteFerieTableAdapter();
|
|
taComm = new DS_UtilityTableAdapters.CommentiTableAdapter();
|
|
taConfFlux = new DS_DossParTableAdapters.ConfFluxTableAdapter();
|
|
taConfig = new DS_UtilityTableAdapters.ConfigTableAdapter();
|
|
taDatiConf = new DS_ProdTempiTableAdapters.DatiConfermatiTableAdapter();
|
|
taDatiMacchine = new DS_ProdTempiTableAdapters.DatiMacchineTableAdapter();
|
|
taDatiProd = new DS_ProdTempiTableAdapters.DatiProduzioneTableAdapter();
|
|
taDatiProdMacch = new DS_ProdTempiTableAdapters.stp_repDonati_getDatiProdMacchinaTableAdapter();
|
|
taDatiProdMacchPer = new DS_ProdTempiTableAdapters.stp_repDonati_getDatiProdMacchinaPeriodoTableAdapter();
|
|
taDatiStatoMacch = new DS_ProdTempiTableAdapters.stp_repDonati_getLastStatoDurataMacchinaTableAdapter();
|
|
taDiarioDich = new DS_applicazioneTableAdapters.DiarioDichiarazioniTableAdapter();
|
|
taDOSS = new DS_DossParTableAdapters.DossiersTableAdapter();
|
|
taEventi = new DS_applicazioneTableAdapters.EventListTableAdapter();
|
|
taFL = new DS_applicazioneTableAdapters.FluxLogTableAdapter();
|
|
taIS_TrDati = new DS_IntServTableAdapters.TransitoDatiTableAdapter();
|
|
taIstK = new DS_IntServTableAdapters.IstanzeKITTableAdapter();
|
|
taKeepAlive = new DS_applicazioneTableAdapters.KeepAliveTableAdapter();
|
|
taListVal = new DS_UtilityTableAdapters.v_selListValTableAdapter();
|
|
taM2S = new DS_ProdTempiTableAdapters.Macchine2SlaveTableAdapter();
|
|
taMacchine = new DS_applicazioneTableAdapters.MacchineTableAdapter();
|
|
taMacParams = new DS_PlanTableAdapters.MachineParamsTableAdapter();
|
|
taMagELotti = new DS_MAGTableAdapters.ElencoLottiTableAdapter();
|
|
taMSE = new DS_ProdTempiTableAdapters.MappaStatoExplTableAdapter();
|
|
taODL = new DS_ProdTempiTableAdapters.ODLTableAdapter();
|
|
taOp = new DS_applicazioneTableAdapters.AnagraficaOperatoriTableAdapter();
|
|
taOp2ins = new DS_applicazioneTableAdapters.AnagraficaOperatori2insTableAdapter();
|
|
taPlanCalDisp = new DS_PlanTableAdapters.CalDispTableAdapter();
|
|
taPlanCalStop = new DS_PlanTableAdapters.CalStopTableAdapter();
|
|
taPlanRichieste = new DS_PlanTableAdapters.RichiesteTableAdapter();
|
|
taPODL = new DS_ProdTempiTableAdapters.PromesseODLTableAdapter();
|
|
taPostazioni = new DS_ProdTempiTableAdapters.PostazioniMapoTableAdapter();
|
|
taPromIn = new DS_PlanTableAdapters.PromesseINTableAdapter();
|
|
taPromOut = new DS_PlanTableAdapters.PromesseOUTTableAdapter();
|
|
taPzProd2conf = new DS_ProdTempiTableAdapters.stp_PzProd_getByMacchinaTableAdapter();
|
|
taRC = new DS_ProdTempiTableAdapters.RegistroControlliTableAdapter();
|
|
taRemReb = new DS_applicazioneTableAdapters.RemoteRebootLogTableAdapter();
|
|
taRS = new DS_ProdTempiTableAdapters.RegistroScartiTableAdapter();
|
|
taSelArt = new DS_UtilityTableAdapters.v_selArticoliTableAdapter();
|
|
taSelMacc = new DS_UtilityTableAdapters.v_selMacchineTableAdapter();
|
|
taSelOdlFree = new DS_UtilityTableAdapters.v_selODLTableAdapter();
|
|
taSigLog = new DS_applicazioneTableAdapters.SignalLogTableAdapter();
|
|
taSTA = new DS_SheetTechTableAdapters.ST_ActualTableAdapter();
|
|
taSTAR = new DS_SheetTechTableAdapters.ST_ActualRowTableAdapter();
|
|
taStati = new DS_applicazioneTableAdapters.DiarioDiBordoTableAdapter();
|
|
taStatoMacchine = new DS_applicazioneTableAdapters.StatoMacchineTableAdapter();
|
|
taStatoProd = new DS_ProdTempiTableAdapters.StatoProdTableAdapter();
|
|
taSTChk = new DS_SheetTechTableAdapters.ST_CheckTableAdapter();
|
|
taTempiCicloRilevati = new DS_ProdTempiTableAdapters.TempiCicloRilevatiTableAdapter();
|
|
taTempoByClass = new DS_ProdTempiTableAdapters.stp_TempoByIdxMaccPeriodClassTableAdapter();
|
|
taTKS = new DS_IntServTableAdapters.TKS_SearchTableAdapter();
|
|
taTranIngr = new DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
|
|
taTurniMacc = new DS_ProdTempiTableAdapters.TurniMacchinaTableAdapter();
|
|
taWKS = new DS_IntServTableAdapters.WipSetupKitTableAdapter();
|
|
}
|
|
|
|
// cMemLayer.CRB("confRett");
|
|
/// <summary>
|
|
/// effettua setup dei connection strings da web.config delal singola applicazione
|
|
/// </summary>
|
|
protected virtual void setupConnectionStringBase()
|
|
{
|
|
string connectionString = cMemLayer.confReadString("MoonProConnectionString");
|
|
string connectionStringIS = cMemLayer.confReadString("MoonProConnectionStringIS");
|
|
string connectionStringArca = cMemLayer.confReadString("MoonProConnectionStringArca");
|
|
string connectionStringES3 = cMemLayer.confReadString("MoonProConnectionStringES3");
|
|
string connectionStringFluxData = cMemLayer.confReadString("MoonProConnectionStringFluxData");
|
|
string connectionStringMAG = cMemLayer.confReadString("MoonProConnectionStringMAG");
|
|
// connections del db
|
|
taAG.Connection.ConnectionString = connectionString;
|
|
taAlarmLog.Connection.ConnectionString = connectionString;
|
|
taAnagArt.Connection.ConnectionString = connectionString;
|
|
taAnagEventi.Connection.ConnectionString = connectionString;
|
|
taAnagStati.Connection.ConnectionString = connectionString;
|
|
taAnagTags.Connection.ConnectionString = connectionString;
|
|
taAs400.Connection.ConnectionString = connectionStringIS;
|
|
taArcaGiac.Connection.ConnectionString = connectionStringArca;
|
|
taDecNA.Connection.ConnectionString = connectionString;
|
|
taCalFF.Connection.ConnectionString = connectionString;
|
|
taConfig.Connection.ConnectionString = connectionString;
|
|
taComm.Connection.ConnectionString = connectionString;
|
|
taConfFlux.Connection.ConnectionString = connectionStringFluxData;
|
|
taDatiConf.Connection.ConnectionString = connectionString;
|
|
taDatiMacchine.Connection.ConnectionString = connectionString;
|
|
taDatiProd.Connection.ConnectionString = connectionString;
|
|
taDatiProdMacch.Connection.ConnectionString = connectionString;
|
|
taDatiProdMacchPer.Connection.ConnectionString = connectionString;
|
|
taDatiStatoMacch.Connection.ConnectionString = connectionString;
|
|
taDiarioDich.Connection.ConnectionString = connectionString;
|
|
taDOSS.Connection.ConnectionString = connectionStringFluxData;
|
|
taEventi.Connection.ConnectionString = connectionString;
|
|
taFL.Connection.ConnectionString = connectionStringFluxData;
|
|
taIS_TrDati.Connection.ConnectionString = connectionStringIS;
|
|
taIstK.Connection.ConnectionString = connectionStringIS;
|
|
taKeepAlive.Connection.ConnectionString = connectionString;
|
|
taListVal.Connection.ConnectionString = connectionString;
|
|
taM2S.Connection.ConnectionString = connectionString;
|
|
taMacchine.Connection.ConnectionString = connectionString;
|
|
taMacParams.Connection.ConnectionString = connectionStringES3;
|
|
taMagELotti.Connection.ConnectionString = connectionStringMAG;
|
|
taMSE.Connection.ConnectionString = connectionString;
|
|
taODL.Connection.ConnectionString = connectionString;
|
|
taOp.Connection.ConnectionString = connectionString;
|
|
taOp2ins.Connection.ConnectionString = connectionString;
|
|
taPlanCalDisp.Connection.ConnectionString = connectionStringES3;
|
|
taPlanCalStop.Connection.ConnectionString = connectionStringES3;
|
|
taPlanRichieste.Connection.ConnectionString = connectionStringES3;
|
|
taPODL.Connection.ConnectionString = connectionString;
|
|
taPostazioni.Connection.ConnectionString = connectionString;
|
|
taPromIn.Connection.ConnectionString = connectionStringES3;
|
|
taPromOut.Connection.ConnectionString = connectionStringES3;
|
|
taPzProd2conf.Connection.ConnectionString = connectionString;
|
|
taRC.Connection.ConnectionString = connectionString;
|
|
taRemReb.Connection.ConnectionString = connectionString;
|
|
taRS.Connection.ConnectionString = connectionString;
|
|
taSelArt.Connection.ConnectionString = connectionString;
|
|
taSelMacc.Connection.ConnectionString = connectionString;
|
|
taSelOdlFree.Connection.ConnectionString = connectionString;
|
|
taSigLog.Connection.ConnectionString = connectionString;
|
|
taSTA.Connection.ConnectionString = connectionString;
|
|
taSTAR.Connection.ConnectionString = connectionString;
|
|
taStati.Connection.ConnectionString = connectionString;
|
|
taStatoMacchine.Connection.ConnectionString = connectionString;
|
|
taStatoProd.Connection.ConnectionString = connectionString;
|
|
taSTChk.Connection.ConnectionString = connectionString;
|
|
taTempiCicloRilevati.Connection.ConnectionString = connectionString;
|
|
taTempoByClass.Connection.ConnectionString = connectionString;
|
|
taTKS.Connection.ConnectionString = connectionStringIS;
|
|
taTranIngr.Connection.ConnectionString = connectionString;
|
|
taTurniMacc.Connection.ConnectionString = connectionString;
|
|
taWKS.Connection.ConnectionString = connectionStringIS;
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Connessione lazy a redis...
|
|
/// </summary>
|
|
private Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
|
|
{
|
|
string RedisConn = cMemLayer.confReadString("RedisConnSPEC");
|
|
if (string.IsNullOrEmpty(RedisConn))
|
|
{
|
|
RedisConn = cMemLayer.confReadString("RedisConn");
|
|
}
|
|
if (string.IsNullOrEmpty(RedisConn))
|
|
{
|
|
RedisConn = "localhost,abortConnect=false,ssl=false";
|
|
}
|
|
return ConnectionMultiplexer.Connect(RedisConn);
|
|
});
|
|
|
|
/// <summary>
|
|
/// Connessione lazy a redis...
|
|
/// </summary>
|
|
private Lazy<ConnectionMultiplexer> lazyConnectionAdmin = new Lazy<ConnectionMultiplexer>(() =>
|
|
{
|
|
string RedisConnAdmin = cMemLayer.confReadString("RedisConnSPECAdmin");
|
|
if (string.IsNullOrEmpty(RedisConnAdmin))
|
|
{
|
|
RedisConnAdmin = cMemLayer.confReadString("RedisConnAdmin");
|
|
}
|
|
if (string.IsNullOrEmpty(RedisConnAdmin))
|
|
{
|
|
RedisConnAdmin = "localhost,abortConnect=false,ssl=false,allowAdmin=true";
|
|
}
|
|
return ConnectionMultiplexer.Connect(RedisConnAdmin);
|
|
});
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private static memLayer cMemLayer { get; set; } = new memLayer();
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
private static T ConvertDataRowToGenericType<T>(DataRow row) where T : class, new()
|
|
{
|
|
Type entityType = typeof(T);
|
|
T objEntity = new T();
|
|
foreach (DataColumn column in row.Table.Columns)
|
|
{
|
|
object value = row[column.ColumnName];
|
|
if (value == DBNull.Value) value = null;
|
|
PropertyInfo property = entityType.GetProperty(column.ColumnName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
|
|
try
|
|
{
|
|
if (property != null && property.CanWrite)
|
|
property.SetValue(objEntity, value, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
return objEntity;
|
|
}
|
|
|
|
/// <summary>
|
|
/// registra su REDIS eventuale superamento numero limite di call x il metodo in oggetto
|
|
/// </summary>
|
|
/// <param name="callCountKey"></param>
|
|
private static void saveCallRec(string callCountKey)
|
|
{
|
|
// conto la richiesta nel contatore REDIS
|
|
long nCall = cMemLayer.setRCntI(mHash($"COUNT:pCall:{callCountKey}"));
|
|
//... se == nCall2Log scrivo su log e resetto
|
|
long nCall2Log = cMemLayer.cdvi("nCall2Log");
|
|
if (nCall >= nCall2Log)
|
|
{
|
|
// loggo
|
|
Log.Info($"{callCountKey}: {nCall} call received", tipoLog.INFO);
|
|
// resetto!
|
|
cMemLayer.resetRCnt(mHash($"COUNT:pCall:{callCountKey}"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// verifica se sia necessario inserire un cambio di stato impianto in modalità batch
|
|
/// </summary>
|
|
/// <param name="tipoInput"></param>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="InizioStato"></param>
|
|
/// <param name="IdxTipo"></param>
|
|
/// <param name="CodArt"></param>
|
|
/// <param name="Value"></param>
|
|
/// <param name="MatrOpr"></param>
|
|
/// <param name="pallet"></param>
|
|
private void checkCambiaStatoBatch(tipoInputEvento tipoInput, string IdxMacchina, DateTime InizioStato, int IdxTipo, string CodArt, string Value, int MatrOpr, string pallet)
|
|
{
|
|
int _logLevel = cMemLayer.CRI("_logLevel");
|
|
DS_applicazione.TransizioneStatiDataTable tabTransStati;
|
|
DS_applicazione.TransizioneStatiRow rigaTransStati;
|
|
switch (tipoInput)
|
|
{
|
|
case tipoInputEvento.barcode:
|
|
// effettuo cambio stato INDIPENDENTEMENTE da stato precedente
|
|
try
|
|
{
|
|
tabTransStati = MapoDbObj.taTranSt.GetUserForcedTransitions(IdxMacchina, IdxTipo);
|
|
if (tabTransStati != null)
|
|
{
|
|
if (tabTransStati.Count > 0)
|
|
{
|
|
rigaTransStati = tabTransStati[0];
|
|
// solo se cambia stato...
|
|
if (rigaTransStati.IdxStato != rigaTransStati.next_IdxStato)
|
|
{
|
|
MapoDbObj.taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, CodArt, Value, MatrOpr, pallet);
|
|
// aggiorno MSE
|
|
taMSE.forceRecalc(0, IdxMacchina);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_logLevel > 6)
|
|
{
|
|
Log.Info($"Non trovata riga per: BARCODE | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}", tipoLog.INFO);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// non dovrebbe succedere... input utente da barcode dovrebbero TUTTI essere
|
|
// inseriti in tab transizione con famiglia 1...
|
|
Log.Info($"Errore controllo transizione stato x evento barcode: BARCODE | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
break;
|
|
|
|
case tipoInputEvento.hw:
|
|
// verifico se ci sia necessità di cambio stato
|
|
try
|
|
{
|
|
tabTransStati = MapoDbObj.taTranSt.GetHwTransitions(IdxMacchina, IdxTipo);
|
|
if (tabTransStati != null)
|
|
{
|
|
if (tabTransStati.Count > 0)
|
|
{
|
|
rigaTransStati = tabTransStati[0];
|
|
if (rigaTransStati != null)
|
|
{
|
|
// solo se cambia stato...
|
|
if (rigaTransStati.IdxStato != rigaTransStati.next_IdxStato)
|
|
{
|
|
MapoDbObj.taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, CodArt, Value, MatrOpr, pallet);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_logLevel > 6)
|
|
{
|
|
Log.Info($"Non trovata riga per: HW | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}", tipoLog.INFO);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// non trovo riga [0]... NON scrivo!
|
|
Log.Info($"Errore controllo transizione stato x evento barcode: HW | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool doCloseCurrODL(string idxMacchina, bool doConfirm, int qtyConf, DS_ProdTempi.ODLDataTable currODLData, DateTime dtEvento, int matrOpr)
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
bool fatto = false;
|
|
// registro un evento di attrezzaggio (idxTipoEv = 2) PRIMA di chiudere ODL
|
|
int idxEvento = 2;
|
|
Log.Info($"Invio evento attrezzaggio x CHIUSURA ODL | idxMacc {idxMacchina} | idxEv {idxEvento} | CodArt {currODLData[0].CodArticolo} | qtyConf {qtyConf}", tipoLog.INFO);
|
|
|
|
// invio un evento x messa in manuale macchina x attrezzaggio in chiusura
|
|
inputComandoMapo resCmd = scriviRigaEventoBarcode(idxMacchina, idxEvento, currODLData[0].CodArticolo, "ODL-CLOSE-ATTR", 0, "", dtEvento, adesso);
|
|
if (doConfirm)
|
|
{
|
|
// modifico la dataEvento
|
|
dtEvento.AddMilliseconds(200);
|
|
// chiamo conferma produzione...
|
|
try
|
|
{
|
|
string chiamata = confRett ? "confermaProdMacchinaFull" : "confermaProdMacchina";
|
|
Log.Info($"Chiamata a {chiamata} con parametri | IdxMacchina: {currODLData[0].IdxMacchina} | MatrOpr: {MatrOpr} | dtEvent {dtEvento} | {qtyConf} | modoConf: {cMemLayer.CRI("modoConfProd")}", tipoLog.INFO);
|
|
string idxMacchinaSel = currODLData[0].IdxMacchina;
|
|
if (confRett)
|
|
{
|
|
// confermo al netto dei pezzi lasciati...
|
|
fatto = confermaProdMacchinaFull(idxMacchinaSel, cMemLayer.CRI("modoConfProd"), qtyConf, 0, 0, dtEvento, matrOpr);
|
|
}
|
|
else
|
|
{
|
|
fatto = confermaProdMacchina(idxMacchinaSel, cMemLayer.CRI("modoConfProd"), qtyConf, 0, dtEvento, matrOpr);
|
|
}
|
|
if (!fatto)
|
|
{
|
|
Log.Info($"ERRORE in chiamata {chiamata}", tipoLog.ERROR);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in doCloseCurrODL{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
dtEvento.AddMilliseconds(200);
|
|
// chiamo chiusura
|
|
MapoDbObj.taODL.forceClose(currODLData[0].IdxODL, idxMacchina, dtEvento);
|
|
// elimino eventuale ODL precedente...
|
|
string rKey = cMemLayer.redHash($"ODL:{idxMacchina}");
|
|
cMemLayer.setRSV(rKey, "");
|
|
fatto = true;
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// sistemazione timeout comandi nei tableadapter
|
|
/// </summary>
|
|
private void fixCommandTimeout()
|
|
{
|
|
int sqlLongCommandTimeout = cMemLayer.CRI("sqlLongCommandTimeout") > 1 ? cMemLayer.CRI("sqlLongCommandTimeout") : 300;
|
|
SetAllCommandTimeouts(taComm, sqlLongCommandTimeout);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero dati stato prod da macchina...
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="datiProdAct"></param>
|
|
/// <param name="dataRif"></param>
|
|
/// <returns></returns>
|
|
private bool getStatoProd(string idxMacchina, ref DS_ProdTempi.StatoProdDataTable datiProdAct, DateTime dataRif)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// recupero con stored NUOVA...
|
|
//2020.01.31 NUOVO oggetto (NON singleton)
|
|
DataLayer man = new DataLayer();
|
|
datiProdAct = man.taStatoProd.GetData(idxMacchina, dataRif);
|
|
if (datiProdAct.Rows.Count > 0)
|
|
{
|
|
// solo SE ho idxODL (altrimenti loggo errore)
|
|
if (datiProdAct[0].IdxOdl > 0)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
// verifico se ho già questo errore attivo IN REDIS (altrimenti reinvio)
|
|
Log.Info($"pzCounterTC: Non trovato currODL x idxMacchina {idxMacchina} ", $"idxMacchina {idxMacchina} | IdxOdl {datiProdAct[0].IdxOdl} | pzTot {datiProdAct[0].PzTotODL} | dataRif {dataRif}", tipoLog.WARNING);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.Info($"pzCounterTC: Non trovate righe in currODL {idxMacchina}", $"Non trovate righe in currODL x idxMacchina {idxMacchina}: datiProdAct vuota", tipoLog.WARNING);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"[pzCounterTC] Eccezione in pzCounterTC x idxMacchina {idxMacchina}", $"[pzCounterTC] Eccezione in pzCounterTC x idxMacchina {idxMacchina}{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola l'effettivo valore da passare alla macchina a stati INGRESSI data conf Macchine2FamigliaIngressi
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="valore"></param>
|
|
/// <returns></returns>
|
|
private string preProcInput(string idxMacchina, string valore)
|
|
{
|
|
string newVal = "";
|
|
try
|
|
{
|
|
// variabili
|
|
int valINT = 0;
|
|
int BitFilt = 0;
|
|
int BSR = 0;
|
|
bool ExplodeBit = false;
|
|
int NumBit = 0;
|
|
int newValInt = 0;
|
|
// recupero parametri...
|
|
int.TryParse(mDatiMacchinaVal(idxMacchina, "BitFilt"), out BitFilt);
|
|
int.TryParse(mDatiMacchinaVal(idxMacchina, "BSR"), out BSR);
|
|
Boolean.TryParse(mDatiMacchinaVal(idxMacchina, "ExplodeBit"), out ExplodeBit);
|
|
int.TryParse(mDatiMacchinaVal(idxMacchina, "NumBit"), out NumBit); // non usato (x ora)
|
|
// recupero valore
|
|
valINT = int.Parse(valore, NumberStyles.HexNumber);
|
|
// filtro
|
|
newValInt = utility.bMaskInt(valINT, BitFilt);
|
|
// effettuo eventuale BitShiftRight
|
|
if (BSR > 0)
|
|
{
|
|
newValInt = newValInt >> BSR;
|
|
}
|
|
// effettuo eventuale esplosione in BIT esclusivi
|
|
if (ExplodeBit)
|
|
{
|
|
newValInt = Convert.ToInt32(1 << newValInt);
|
|
}
|
|
// riconverto a STRING HEX!!!
|
|
newVal = newValInt.ToString("X");
|
|
}
|
|
catch
|
|
{
|
|
newVal = valore;
|
|
}
|
|
|
|
return newVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset cache REDIS dati PODL
|
|
/// </summary>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
private void resetPODLData(int idxPODL)
|
|
{
|
|
string rKey = getPOdlRowHash(idxPODL);
|
|
cMemLayer.setRSV(rKey, "", 1);
|
|
}
|
|
|
|
private string saveOdlData(string idxMacchina, DS_ProdTempi.ODLDataTable currODLData, DS_ProdTempi.PromesseODLDataTable reqPODLData)
|
|
{
|
|
string answ;
|
|
// recupera ODL macchina
|
|
var newOdl = currODL(idxMacchina, true);
|
|
// attendo 1000 msec registro fine ODL (idxTipoEv = 1)
|
|
int idxEvento = 1;
|
|
Log.Info($"Invio evento ODL-forced start per macchina {idxMacchina}, evento {idxEvento}, articolo {currODLData[0].CodArticolo}", tipoLog.INFO);
|
|
var resCmd = scriviRigaEventoBarcode(idxMacchina, idxEvento, currODLData[0].CodArticolo, "ODL-FORCE-START");
|
|
// invio eventi setup a macchina....
|
|
string setArtVal = $"{currODLData[0].CodArticolo}";
|
|
string setPzCommVal = $"{reqPODLData[0].NumPezzi}";
|
|
string setCommVal = $"ODL{newOdl}";
|
|
if (!string.IsNullOrEmpty(reqPODLData[0].KeyRichiesta))
|
|
{
|
|
setCommVal = $"{reqPODLData[0].KeyRichiesta} ODL{newOdl}";
|
|
}
|
|
try
|
|
{
|
|
// invio task caricamento dati ODL
|
|
addTask4Machine(idxMacchina, taskType.setArt, setArtVal);
|
|
addTask4Machine(idxMacchina, taskType.setComm, setCommVal);
|
|
addTask4Machine(idxMacchina, taskType.setPzComm, setPzCommVal);
|
|
updateMachineParameter(idxMacchina, "setArt", setArtVal);
|
|
updateMachineParameter(idxMacchina, "setComm", setCommVal);
|
|
updateMachineParameter(idxMacchina, "setPzComm", setPzCommVal);
|
|
}
|
|
catch
|
|
{ }
|
|
// chiamo refresh MSE
|
|
taMSE.forceRecalc(0, idxMacchina);
|
|
// resetto stato macchina...
|
|
cMemLayer.redDelKey(currStatoMaccHash(idxMacchina));
|
|
answ = "OK";
|
|
Log.Info($"Effettuato reset e ricalcoli x split ODL per macchina {idxMacchina}", tipoLog.INFO);
|
|
// se è una master richiamo fix x child...
|
|
if (isMaster(idxMacchina))
|
|
{
|
|
string ts = "";
|
|
string outData = "";
|
|
taODL.fixMachineSlave(idxMacchina, 30, 1);
|
|
// ciclo su ogni slave la gestione reinvio pezzi -->calcolo gli slave...
|
|
var slaveList = taM2S.getByMaster(idxMacchina);
|
|
foreach (var machine in slaveList)
|
|
{
|
|
// invio chiusura attrezzaggio
|
|
ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
|
|
outData = $"TS:{ts}|MATR:{MatrOpr}|ODL:{newOdl}";
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.fixStopSetup, outData);
|
|
|
|
// invio task caricamento dati ODL
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.setArt, setArtVal);
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.setComm, setCommVal);
|
|
addTask4Machine(machine.IdxMacchinaSlave, taskType.setPzComm, setPzCommVal);
|
|
|
|
updateMachineParameter(machine.IdxMacchinaSlave, "setArt", setArtVal);
|
|
updateMachineParameter(machine.IdxMacchinaSlave, "setComm", setCommVal);
|
|
updateMachineParameter(machine.IdxMacchinaSlave, "setPzComm", setPzCommVal);
|
|
}
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
private void SetAllCommandTimeouts(object adapter, int timeout)
|
|
{
|
|
var commands = adapter.GetType().InvokeMember(
|
|
"CommandCollection",
|
|
BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic,
|
|
null, adapter, new object[0]);
|
|
var sqlCommand = (SqlCommand[])commands;
|
|
foreach (var cmd in sqlCommand)
|
|
{
|
|
cmd.CommandTimeout = timeout;
|
|
}
|
|
}
|
|
|
|
private void setupConf()
|
|
{
|
|
confRett = cMemLayer.CRB("confRett");
|
|
}
|
|
|
|
/// <summary>
|
|
/// cerca codice in anagrafica macchine ed eventualmente inserisce nuova macchina
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
private void verificaIdxMacchina(string IdxMacchina)
|
|
{
|
|
bool needDB = false;
|
|
if (!cMemLayer.CRB("disable_verificaIdxMacchina"))
|
|
{
|
|
if (cMemLayer.CRB("IOB_RedEnab"))
|
|
{
|
|
try
|
|
{
|
|
// esecuzione in REDIS...cerco status macchina...
|
|
if (mDatiMacchine(IdxMacchina).Count == 0)
|
|
{
|
|
needDB = true;
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
// ...oppure segno richiesta DB...
|
|
else
|
|
{
|
|
needDB = true;
|
|
}
|
|
if (needDB)
|
|
{
|
|
// 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione
|
|
// NUOVO oggetto
|
|
if (cMemLayer.CRB("disable_singleton"))
|
|
{
|
|
taMacchine = new DS_applicazioneTableAdapters.MacchineTableAdapter();
|
|
MapoDbObj.taMSM = new DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter();
|
|
}
|
|
// verifico esistenza macchina
|
|
if (taMacchine.GetByIdx(IdxMacchina).Rows.Count == 0)
|
|
{
|
|
// inserisco nuova macchina...
|
|
taMacchine.Insert(IdxMacchina, "9999", IdxMacchina, "Macchina non codificata", "-", "http://", "nd", "col", 0, 0);
|
|
}
|
|
// verifico ci sia un microstato macchina...
|
|
if (MapoDbObj.taMSM.getByIdxMacchina(IdxMacchina).Rows.Count == 0)
|
|
{
|
|
// inserisco nuovo stato...
|
|
MapoDbObj.taMSM.Insert(IdxMacchina, 0, DateTime.Now, "00");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |