Samuele E. Locatelli
1441 lines
64 KiB
C#
1441 lines
64 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Configuration;
|
|
using System.Runtime.InteropServices;
|
|
using SteamWare;
|
|
using System.Data;
|
|
|
|
namespace MapoDb
|
|
{
|
|
|
|
public struct inputComando
|
|
{
|
|
/// <summary>
|
|
/// input comando valido si/no
|
|
/// </summary>
|
|
public bool isValid;
|
|
/// <summary>
|
|
/// testo da mostrare all'utente
|
|
/// </summary>
|
|
public string text2show;
|
|
/// <summary>
|
|
/// idx evento associato al comando
|
|
/// </summary>
|
|
public int idxTipoEvento;
|
|
/// <summary>
|
|
/// input precedente
|
|
/// </summary>
|
|
public string precInput;
|
|
/// <summary>
|
|
/// descrizione comando
|
|
/// </summary>
|
|
public string descrComando;
|
|
/// <summary>
|
|
/// refresh stato macchina encessario si/no
|
|
/// </summary>
|
|
public bool needStatusRefresh;
|
|
/// <summary>
|
|
/// lista del nome dei WebBrowserBox e delle relative url, nel formato {0}##{1} {0}=nome WebBrowserBox (es. box01), {1}=url relativo (es. http://server/MoonPro/Produzione.aspx?idxMacchina=99)
|
|
/// </summary>
|
|
public string[] wBrowsBoxUrls;
|
|
/// <summary>
|
|
/// valore di output dal comando
|
|
/// </summary>
|
|
public string outValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// tipologia evento inviato
|
|
/// </summary>
|
|
public enum tipoInputEvento
|
|
{
|
|
barcode,
|
|
hw
|
|
}
|
|
/// <summary>
|
|
/// nuovo stato ingressi e eventuale evento da inviare
|
|
/// </summary>
|
|
public struct hwMachineState
|
|
{
|
|
public int next_IdxMicroStato;
|
|
public int IdxTipoEvento;
|
|
}
|
|
|
|
public class MapoDb
|
|
{
|
|
#region area protected
|
|
|
|
protected string _separatore = ",";
|
|
protected string _connectionString = "";
|
|
|
|
#region area table adapters
|
|
|
|
// area applicazione
|
|
protected DS_applicazioneTableAdapters.EventListTableAdapter taEvList;
|
|
protected DS_applicazioneTableAdapters.DiarioDiBordoTableAdapter taDiario;
|
|
protected DS_applicazioneTableAdapters.AnagraficaEventiTableAdapter taAnagEv;
|
|
protected DS_applicazioneTableAdapters.AnagraficaStatiTableAdapter taAnagSt;
|
|
protected DS_applicazioneTableAdapters.MacchineTableAdapter taMacchine;
|
|
protected DS_applicazioneTableAdapters.KanbanTableAdapter taKanban;
|
|
protected DS_applicazioneTableAdapters.TransizioneEventiTableAdapter taTranEv;
|
|
protected DS_applicazioneTableAdapters.TransizioneStatiTableAdapter taTranSt;
|
|
protected DS_applicazioneTableAdapters.StatoMacchineTableAdapter taStatoMacchine;
|
|
protected DS_applicazioneTableAdapters.KeepAliveTableAdapter taKeepAlive;
|
|
protected DS_applicazioneTableAdapters.RemoteRebootLogTableAdapter taRRL;
|
|
protected DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter taTransIngr;
|
|
protected DS_applicazioneTableAdapters.AnagraficaOperatoriTableAdapter taAnOpr;
|
|
protected DS_applicazioneTableAdapters.DatiMacchineTableAdapter taDatiMacch;
|
|
protected DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter taMSM;
|
|
|
|
// area tempi ciclo
|
|
protected DS_ProdTempiTableAdapters.TempiCicloRilevatiTableAdapter taTCRilevati;
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// avvio i table adapter della classe
|
|
/// </summary>
|
|
private void AvviaTabAdapt()
|
|
{
|
|
taEvList = new global::MapoDb.DS_applicazioneTableAdapters.EventListTableAdapter();
|
|
taDiario = new global::MapoDb.DS_applicazioneTableAdapters.DiarioDiBordoTableAdapter();
|
|
taAnagSt = new global::MapoDb.DS_applicazioneTableAdapters.AnagraficaStatiTableAdapter();
|
|
taAnagEv = new global::MapoDb.DS_applicazioneTableAdapters.AnagraficaEventiTableAdapter();
|
|
taMacchine = new global::MapoDb.DS_applicazioneTableAdapters.MacchineTableAdapter();
|
|
taKanban = new global::MapoDb.DS_applicazioneTableAdapters.KanbanTableAdapter();
|
|
taTranEv = new global::MapoDb.DS_applicazioneTableAdapters.TransizioneEventiTableAdapter();
|
|
taTranSt = new global::MapoDb.DS_applicazioneTableAdapters.TransizioneStatiTableAdapter();
|
|
taStatoMacchine = new global::MapoDb.DS_applicazioneTableAdapters.StatoMacchineTableAdapter();
|
|
taKeepAlive = new global::MapoDb.DS_applicazioneTableAdapters.KeepAliveTableAdapter();
|
|
taRRL = new global::MapoDb.DS_applicazioneTableAdapters.RemoteRebootLogTableAdapter();
|
|
taTransIngr = new global::MapoDb.DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
|
|
taAnOpr = new global::MapoDb.DS_applicazioneTableAdapters.AnagraficaOperatoriTableAdapter();
|
|
taDatiMacch = new global::MapoDb.DS_applicazioneTableAdapters.DatiMacchineTableAdapter();
|
|
taMSM = new global::MapoDb.DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter();
|
|
|
|
taTCRilevati = new global::MapoDb.DS_ProdTempiTableAdapters.TempiCicloRilevatiTableAdapter();
|
|
}
|
|
/// <summary>
|
|
/// forza la connString x i vari table adapters
|
|
/// </summary>
|
|
private void setConnString()
|
|
{
|
|
_connectionString = SteamWare.memLayer.ML.confReadString("MoonProConnectionString");
|
|
taEvList.Connection.ConnectionString = _connectionString;
|
|
taDiario.Connection.ConnectionString = _connectionString;
|
|
taAnagEv.Connection.ConnectionString = _connectionString;
|
|
taAnagSt.Connection.ConnectionString = _connectionString;
|
|
taMacchine.Connection.ConnectionString = _connectionString;
|
|
taKanban.Connection.ConnectionString = _connectionString;
|
|
taTranEv.Connection.ConnectionString = _connectionString;
|
|
taTranSt.Connection.ConnectionString = _connectionString;
|
|
taStatoMacchine.Connection.ConnectionString = _connectionString;
|
|
taKeepAlive.Connection.ConnectionString = _connectionString;
|
|
taRRL.Connection.ConnectionString = _connectionString;
|
|
taTransIngr.Connection.ConnectionString = _connectionString;
|
|
taAnOpr.Connection.ConnectionString = _connectionString;
|
|
taDatiMacch.Connection.ConnectionString = _connectionString;
|
|
taMSM.Connection.ConnectionString = _connectionString;
|
|
|
|
taTCRilevati.Connection.ConnectionString = _connectionString;
|
|
}
|
|
/// <summary>
|
|
/// cerca codice in anagrafica macchine ed eventualmente inserisce nuova macchina
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
private void verificaIdxMacchina(string IdxMacchina)
|
|
{
|
|
// verifico esistenza macchina
|
|
if (taMacchine.GetByIdx(IdxMacchina).Rows.Count == 0)
|
|
{
|
|
// inserisco nuova macchina...
|
|
taMacchine.Insert(IdxMacchina, "9999", IdxMacchina, "Macchina non codificata", "-", "http://", "nd");
|
|
}
|
|
// verifico ci sia un microstato macchina...
|
|
if (taMSM.getByIdxMacchina(IdxMacchina).Rows.Count == 0)
|
|
{
|
|
// inserisco nuovo stato...
|
|
taMSM.Insert(IdxMacchina, 0, DateTime.Now, "00");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// verifica se sia necessario inserire un cambio di stato impianto
|
|
/// </summary>
|
|
/// <param name="tipoInput"></param>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="IdxTipo"></param>
|
|
/// <param name="matrKanban"></param>
|
|
/// <param name="Value"></param>
|
|
private void checkCambiaStato(tipoInputEvento tipoInput, string IdxMacchina, int IdxTipo, string matrKanban, string Value, int MatrOpr, string pallet)
|
|
{
|
|
DS_applicazione.TransizioneStatiRow rigaTransStati;
|
|
switch (tipoInput)
|
|
{
|
|
case tipoInputEvento.barcode:
|
|
// effettuo cambio stato INDIPENDENTEMENTE da stato precedente
|
|
try
|
|
{
|
|
rigaTransStati = taTranSt.GetUserForcedTransitions(IdxMacchina, IdxTipo)[0];
|
|
taDiario.InsStato(IdxMacchina, rigaTransStati.next_IdxStato, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// non dovrebbe succedere... input utente da barcode dovrebbero TUTTI essere inseriti in tab transizione con famiglia 1...
|
|
logger.lg.scriviLog(string.Format("Errore controllo transizione stato x evento barcode:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
break;
|
|
case tipoInputEvento.hw:
|
|
// verifico se ci sia necessità di cambio stato
|
|
try
|
|
{
|
|
rigaTransStati = taTranSt.GetHwTransitions(IdxMacchina, IdxTipo)[0];
|
|
if (rigaTransStati != null)
|
|
{
|
|
taDiario.InsStato(IdxMacchina, rigaTransStati.next_IdxStato, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// non trovo riga [0]... NON scrivo!
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/// <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="matrKanban"></param>
|
|
/// <param name="Value"></param>
|
|
private void checkCambiaStatoBatch(tipoInputEvento tipoInput, string IdxMacchina, DateTime InizioStato, int IdxTipo, string matrKanban, string Value, int MatrOpr, string pallet)
|
|
{
|
|
DS_applicazione.TransizioneStatiRow rigaTransStati;
|
|
switch (tipoInput)
|
|
{
|
|
case tipoInputEvento.barcode:
|
|
// effettuo cambio stato INDIPENDENTEMENTE da stato precedente
|
|
try
|
|
{
|
|
rigaTransStati = taTranSt.GetUserForcedTransitions(IdxMacchina, IdxTipo)[0];
|
|
taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// non dovrebbe succedere... input utente da barcode dovrebbero TUTTI essere inseriti in tab transizione con famiglia 1...
|
|
logger.lg.scriviLog(string.Format("Errore controllo transizione stato x evento barcode:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
break;
|
|
case tipoInputEvento.hw:
|
|
// verifico se ci sia necessità di cambio stato
|
|
try
|
|
{
|
|
rigaTransStati = taTranSt.GetHwTransitions(IdxMacchina, IdxTipo)[0];
|
|
if (rigaTransStati != null)
|
|
{
|
|
taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// non trovo riga [0]... NON scrivo!
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// metodo privato x fornire matricola che è correntemente sulla macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
private int getMatrOpMacc(string idxMacchina)
|
|
{
|
|
int matr = -1;
|
|
try
|
|
{
|
|
matr = (taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0]).MatrOpr;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return matr;
|
|
}
|
|
/// <summary>
|
|
/// metodo privato x fornire cognome-nome dalla matricola
|
|
/// </summary>
|
|
/// <param name="matrOpr"></param>
|
|
/// <returns></returns>
|
|
private string getGeneralitDaMatr(int matrOpr)
|
|
{
|
|
string cognNome = "";
|
|
// cerco operatore...
|
|
DS_applicazione.AnagraficaOperatoriRow rigaOpr;
|
|
try
|
|
{
|
|
rigaOpr = (DS_applicazione.AnagraficaOperatoriRow)(taAnOpr.getByMatrOpr(matrOpr)[0]);
|
|
cognNome = string.Format("{0} {1}", rigaOpr.Cognome, rigaOpr.Nome);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return cognNome;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region area public
|
|
|
|
/// <summary>
|
|
/// avvio della classe
|
|
/// </summary>
|
|
public MapoDb()
|
|
{
|
|
AvviaTabAdapt();
|
|
}
|
|
/// <summary>
|
|
/// Oggetto singleton x MapoDb
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static MapoDb obj = new MapoDb();
|
|
/// <summary>
|
|
/// restituisce la stringa di connessione al db
|
|
/// </summary>
|
|
public string getStringaConnessione()
|
|
{
|
|
return _connectionString;
|
|
}
|
|
/// <summary>
|
|
/// imposta la stringa di connessione al db
|
|
/// </summary>
|
|
public bool setStringaConnessione(string valore)
|
|
{
|
|
_connectionString = valore;
|
|
setConnString();
|
|
return true;
|
|
}
|
|
/// <summary>
|
|
/// scrive una riga di evento nel db
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxTipo">idx evento</param>
|
|
/// <param name="matrKanban">matricola prodotto (kanban)</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 inputComando scriviRigaEvento(string IdxMacchina, int IdxTipo, string matrKanban, 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 evento
|
|
inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStato(tipoInputEvento.hw, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} matrKanban {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet, eventTime, currentTime), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
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="matrKanban">matricola prodotto (kanban)</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <returns></returns>
|
|
public inputComando scriviRigaEvento(string IdxMacchina, int IdxTipo, string matrKanban, string Value, int MatrOpr, string pallet)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = taEvList.InsEvento(IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStato(tipoInputEvento.hw, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} matrKanban {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione: {0}{7}", Environment.NewLine, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// restituisce boolean se la amcchian sia abilitata x inserimento dati (tab DatiMacchine)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public bool insEnabled(int idxMacchina)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = ((DS_applicazione.DatiMacchineRow)taDatiMacch.GetByIdx(idxMacchina)[0]).insEnabled;
|
|
}
|
|
catch
|
|
{ }
|
|
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 inputComando checkMicroStato(string idxMacchina, string valore, DateTime dtEve, string contatore)
|
|
{
|
|
if (memLayer.ML.confReadInt("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt]{2}---------------------------{2}Richiesta verifica INPUT per Macchina {0}, seriale {1}", idxMacchina, valore, Environment.NewLine), tipoLog.INFO);
|
|
}
|
|
// scrivo keep alive!
|
|
scriviKeepAlive(idxMacchina, DateTime.Now);
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
DS_applicazione.TransizioneIngressiDataTable TabTransIn;
|
|
DS_applicazione.TransizioneIngressiRow rigaTransIn = null;
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(idxMacchina);
|
|
string kanban = "K";
|
|
// recupero kanban corretto
|
|
try
|
|
{
|
|
kanban = DataLayer.obj.taDatiMacchine.getByIdx(Convert.ToInt32(idxMacchina))[0].kanban_A;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt] - Eccezione in recupero KANBAN:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// recupero next microstato
|
|
//int? valINT = Convert.ToInt32(valore);
|
|
int? valINT = 0;
|
|
try
|
|
{
|
|
valINT = int.Parse(valore, System.Globalization.NumberStyles.HexNumber);
|
|
TabTransIn = taTransIngr.getByIdxMacchinaValore(idxMacchina, valINT);
|
|
if (TabTransIn.Rows.Count > 0)
|
|
{
|
|
rigaTransIn = TabTransIn[0];
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt] - Eccezione in recupero riga Trans ingressi per idxMacchina {3} e valore {2}:{0}{1}", Environment.NewLine, exc, valINT, idxMacchina), tipoLog.EXCEPTION);
|
|
}
|
|
int _logLevel = memLayer.ML.confReadInt("_logLevel");
|
|
// effettuo update vari
|
|
if (rigaTransIn != null)
|
|
{
|
|
try
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt] - 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...
|
|
taMSM.updateQuery(rigaTransIn.next_IdxMicroStato, dtEve, valore, idxMacchina);
|
|
// controllo se c'è evento
|
|
if (rigaTransIn.IdxTipoEvento > 0)
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt] - Salvo evento:{0}macchina: {1} | tipoEvento: {2} | kanban: {3} | contatore: {4} | valore: {5}", Environment.NewLine, idxMacchina, rigaTransIn.IdxTipoEvento, kanban, contatore, valore), tipoLog.INFO);
|
|
}
|
|
string valEsteso = string.Format("[{0}] {1}", contatore.PadLeft(3, '0'), valore);
|
|
answ = scriviRigaEvento(idxMacchina, rigaTransIn.IdxTipoEvento, kanban, valEsteso, 0, "-", dtEve, DateTime.Now); // aggiunto contatore!
|
|
if (_logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt] - Macchina {0} | seriale(INT) {1} | valEsteso {3} | answ {4}{2}---------------------------{2}", idxMacchina, valINT, Environment.NewLine, valEsteso, answ), tipoLog.INFO);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("[ChkMiSt] - 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 inputComando checkMicroStato(string idxMacchina, string valore, DateTime dtEve)
|
|
{
|
|
if (memLayer.ML.confReadInt("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog(string.Format("{2}---------------------------{2}Richiesta verifica INPUT per Macchina {0}, seriale {1}", idxMacchina, valore, Environment.NewLine), tipoLog.INFO);
|
|
}
|
|
// scrivo keep alive!
|
|
scriviKeepAlive(idxMacchina, DateTime.Now);
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
DS_applicazione.TransizioneIngressiDataTable TabTransIn;
|
|
DS_applicazione.TransizioneIngressiRow rigaTransIn = null;
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(idxMacchina);
|
|
string kanban = "K";
|
|
// recupero kanban corretto
|
|
try
|
|
{
|
|
kanban = DataLayer.obj.taDatiMacchine.getByIdx(Convert.ToInt32(idxMacchina))[0].kanban_A;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero KANBAN:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// recupero next microstato
|
|
//int? valINT = Convert.ToInt32(valore);
|
|
int? valINT = 0;
|
|
try
|
|
{
|
|
valINT = int.Parse(valore, System.Globalization.NumberStyles.HexNumber);
|
|
TabTransIn = taTransIngr.getByIdxMacchinaValore(idxMacchina, valINT);
|
|
if (TabTransIn.Rows.Count > 0)
|
|
{
|
|
rigaTransIn = TabTransIn[0];
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero riga Trans ingressi per idxMacchina {3} e valore {2}:{0}{1}", Environment.NewLine, exc, valINT, idxMacchina), tipoLog.EXCEPTION);
|
|
}
|
|
int _logLevel = memLayer.ML.confReadInt("_logLevel");
|
|
// effettuo update vari
|
|
if (rigaTransIn != null)
|
|
{
|
|
try
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog(string.Format("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...
|
|
taMSM.updateQuery(rigaTransIn.next_IdxMicroStato, dtEve, valore, idxMacchina);
|
|
// controllo se c'è evento
|
|
if (rigaTransIn.IdxTipoEvento > 0)
|
|
{
|
|
if (_logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Salvo evento:{0}macchina: {1} | tipoEvento: {2} | kanban: {3}", Environment.NewLine, idxMacchina, rigaTransIn.IdxTipoEvento, kanban), tipoLog.INFO);
|
|
}
|
|
answ = scriviRigaEvento(idxMacchina, rigaTransIn.IdxTipoEvento, kanban, valore, 0, "-", dtEve, DateTime.Now);
|
|
if (_logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Macchina {0}, seriale(INT) {1}{2}---------------------------{2}", idxMacchina, valINT, Environment.NewLine), tipoLog.INFO);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("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 inputComando checkMicroStato(string idxMacchina, string valore)
|
|
{
|
|
// wrapper ad ora corrente...
|
|
return checkMicroStato(idxMacchina, valore, DateTime.Now);
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="IPv4"></param>
|
|
/// <param name="agent"></param>
|
|
/// <param name="macAddr">mac address (inviato dalla macchina)</param>
|
|
/// <returns></returns>
|
|
public inputComando registraStartup(string idxMacchina, string IPv4, string agent, string macAddr)
|
|
{
|
|
if (memLayer.ML.confReadInt("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog(string.Format("{0}---------------------------{0}Richiesta registrazione (ri)avvio Macchina {1} - mac: {2}", Environment.NewLine, idxMacchina, macAddr), tipoLog.INFO);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
// scrivo remote reboot alive!
|
|
scriviRemoteReboot(idxMacchina, IPv4, agent, macAddr);
|
|
// scrivo PRIMO keep alive
|
|
scriviPrimoKeepAlive(idxMacchina, DateTime.Now);
|
|
|
|
|
|
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="matrKanban">matricola prodotto (kanban)</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <returns></returns>
|
|
public inputComando scriviRigaEvento(string IdxMacchina, int IdxTipo, string matrKanban, string Value)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = taEvList.InsEvento(IdxMacchina, IdxTipo, matrKanban, Value, 0, "-");
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStato(tipoInputEvento.hw, IdxMacchina, IdxTipo, matrKanban, Value, 0, "-");
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} matrKanban {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxTipo, matrKanban, Value), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
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="matrKanban">matricola prodotto (kanban)</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 inputComando scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string matrKanban, 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 evento
|
|
inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStato(tipoInputEvento.barcode, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} matrKanban {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet, eventTime, currentTime), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
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="matrKanban">matricola prodotto (kanban)</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <returns></returns>
|
|
public inputComando scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string matrKanban, string Value, int MatrOpr, string pallet)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = taEvList.InsEvento(IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStato(tipoInputEvento.barcode, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} matrKanban {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione: {0}{7}", Environment.NewLine, IdxMacchina, IdxTipo, matrKanban, Value, MatrOpr, pallet, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
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="matrKanban">matricola prodotto (kanban)</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <returns></returns>
|
|
public inputComando scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string matrKanban, string Value)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
inserito = taEvList.InsEvento(IdxMacchina, IdxTipo, matrKanban, Value, 0, "-");
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
checkCambiaStato(tipoInputEvento.barcode, IdxMacchina, IdxTipo, matrKanban, Value, 0, "-");
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} matrKanban {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxTipo, matrKanban, Value), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
/// <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="matrKanban">matricola prodotto (kanban)</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 inputComando scriviRigaStato(string IdxMacchina, int IdxStato, string matrKanban, 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 = taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, matrKanban, "", null, null, MatrOpr, pallet);
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura stato con i seguenti dati:{0} macchina {1}{0} IdxStato {2}{0} matrKanban {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxStato, matrKanban, Value, MatrOpr, pallet, eventTime, currentTime), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
/// <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="matrKanban">matricola prodotto (kanban)</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <param name="MatrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <returns></returns>
|
|
public inputComando scriviRigaStato(string IdxMacchina, int IdxStato, string matrKanban, string Value, int MatrOpr, string pallet)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
|
|
inserito = taDiario.InsStato(IdxMacchina, IdxStato, matrKanban, Value, MatrOpr, pallet);
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura stato con i seguenti dati:{0} macchina {1}{0} IdxStato {2}{0} matrKanban {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione: {0}{7}", Environment.NewLine, IdxMacchina, IdxStato, matrKanban, Value, MatrOpr, pallet), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// scrive una riga di stato nel diario di bordo SENZA operatore e pallet (mette a 0 e "-")
|
|
/// </summary>
|
|
/// <param name="IdxMacchina">codice macchina</param>
|
|
/// <param name="IdxStato">idx stato</param>
|
|
/// <param name="matrKanban">matricola prodotto (kanban)</param>
|
|
/// <param name="Value">valore</param>
|
|
/// <returns></returns>
|
|
public inputComando scriviRigaStato(string IdxMacchina, int IdxStato, string matrKanban, string Value)
|
|
{
|
|
int inserito = 0;
|
|
try
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
|
|
inserito = taDiario.InsStato(IdxMacchina, IdxStato, matrKanban, Value, 0, "-");
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scrittura stato con i seguenti dati:{0} macchina {1}{0} IdxStato {2}{0} matrKanban {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxStato, matrKanban, Value), tipoLog.EXCEPTION);
|
|
}
|
|
// formatto output
|
|
inputComando answ = new inputComando();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce una stringa su 2 righe con intestazione colonne e valore dell'oggetto cercato tutti delimitati da separatore
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public string getAnagEventi(string chiave)
|
|
{
|
|
int IdxTipo = Convert.ToInt32(chiave);
|
|
string _nomi = "";
|
|
string _valori = "";
|
|
DS_applicazione.AnagraficaEventiDataTable tabella = taAnagEv.GetByIdx(IdxTipo);
|
|
foreach (System.Data.DataColumn colonna in tabella.Columns)
|
|
{
|
|
_nomi += string.Format("{0}{1}", colonna.ColumnName, _separatore);
|
|
_valori += string.Format("{0}{1}", tabella[0][colonna.ColumnName], _separatore);
|
|
}
|
|
return string.Format("{0}\n\r{1}\n\r", _nomi, _valori);
|
|
}
|
|
/// <summary>
|
|
/// Restituisce una stringa su 2 righe con intestazione colonne e valore dell'oggetto cercato tutti delimitati da separatore
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public string getAnagStati(string chiave)
|
|
{
|
|
int IdxStato = Convert.ToInt32(chiave);
|
|
string _nomi = "";
|
|
string _valori = "";
|
|
DS_applicazione.AnagraficaStatiDataTable tabella = taAnagSt.GetByIdx(IdxStato);
|
|
foreach (System.Data.DataColumn colonna in tabella.Columns)
|
|
{
|
|
_nomi += string.Format("{0}{1}", colonna.ColumnName, _separatore);
|
|
_valori += string.Format("{0}{1}", tabella[0][colonna.ColumnName], _separatore);
|
|
}
|
|
return string.Format("{0}\n\r{1}\n\r", _nomi, _valori);
|
|
}
|
|
/// <summary>
|
|
/// Restituisce una stringa su 2 righe con intestazione colonne e valore dell'oggetto cercato tutti delimitati da separatore
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public string getAnagMacchine(string chiave)
|
|
{
|
|
string _nomi = "";
|
|
string _valori = "";
|
|
DS_applicazione.MacchineDataTable tabella = taMacchine.GetByIdx(chiave);
|
|
foreach (System.Data.DataColumn colonna in tabella.Columns)
|
|
{
|
|
_nomi += string.Format("{0}{1}", colonna.ColumnName, _separatore);
|
|
_valori += string.Format("{0}{1}", tabella[0][colonna.ColumnName], _separatore);
|
|
}
|
|
return string.Format("{0}\n\r{1}\n\r", _nomi, _valori);
|
|
}
|
|
/// <summary>
|
|
/// fornisce tabella elenco eventi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public DS_applicazione.EventListDataTable elencoEventi()
|
|
{
|
|
return taEvList.GetData();
|
|
}
|
|
/// <summary>
|
|
/// fornisce tabella elenco stati (DiarioDiBordo)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public DS_applicazione.DiarioDiBordoDataTable elencoStati()
|
|
{
|
|
return taDiario.GetData();
|
|
}
|
|
/// <summary>
|
|
/// restituisce l'oggetto tipizzato che rappresenta i dati del setup di una macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public DS_applicazione.DatiMacchineRow getDatiMacchina(int idxMacchina)
|
|
{
|
|
DS_applicazione.DatiMacchineRow answ = null;
|
|
try
|
|
{
|
|
answ = taDatiMacch.GetByIdx(idxMacchina)[0];
|
|
}
|
|
catch
|
|
{
|
|
SteamWare.logger.lg.scriviLog(string.Format("Non sono riuscito a leggere la conf della macchina {0}", idxMacchina), SteamWare.tipoLog.ERROR);
|
|
}
|
|
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 = DataLayer.obj.taTranIngr.getMatriceByIdxMacchina(idxMacchina);
|
|
}
|
|
catch
|
|
{
|
|
answ = null;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
#region scritture eventi simulati
|
|
|
|
public int scriviRigaEventoSimulata(DateTime dataOra, string IdxMacchina, int IdxTipo, string matrKanban, string Value, int MatrOpr, string pallet)
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
int inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, matrKanban, Value, MatrOpr, pallet);
|
|
return inserito;
|
|
}
|
|
public int scriviRigaStatoSimulata(DateTime dataOra, string IdxMacchina, int IdxStato, string matrKanban, 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 = taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, matrKanban, "", null, null, MatrOpr, pallet);
|
|
return inserito;
|
|
}
|
|
|
|
public int scriviRigaEventoSimulata(DateTime dataOra, string IdxMacchina, int IdxTipo, string matrKanban, string Value)
|
|
{
|
|
// verifico se esista la macchina altrimenti la creo...
|
|
verificaIdxMacchina(IdxMacchina);
|
|
// inserisco evento
|
|
int inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, matrKanban, Value, 0, "-");
|
|
return inserito;
|
|
}
|
|
public int scriviRigaStatoSimulata(DateTime dataOra, string IdxMacchina, int IdxStato, string matrKanban, 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 = taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, matrKanban, "", null, null, 0, "-");
|
|
return inserito;
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// cancella tutti gli eventi
|
|
/// </summary>
|
|
public void deleteAllEventi()
|
|
{
|
|
taEvList.DeleteAll();
|
|
}
|
|
/// <summary>
|
|
/// cancella tutti gli stati
|
|
/// </summary>
|
|
public void deleteAllStati()
|
|
{
|
|
taDiario.DeleteAll();
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce una riga di dati relativa ad una macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public DS_applicazione.MacchineRow getRigaMacchina(string idxMacchina)
|
|
{
|
|
return taMacchine.GetByIdx(idxMacchina)[0];
|
|
}
|
|
|
|
public DS_applicazione.EventListDataTable elencoEventiImpianto(string idxMacchina)
|
|
{
|
|
return taEvList.GetDataByIdxMacchina(idxMacchina);
|
|
}
|
|
public DS_applicazione.DiarioDiBordoDataTable elencoStatiImpianto(string idxMacchina)
|
|
{
|
|
return taDiario.GetDataByIdxMacchina(idxMacchina);
|
|
}
|
|
public DS_applicazione.EventListDataTable elencoEventiImpiantoPeriodo(string idxMacchina, DateTime dal, DateTime al)
|
|
{
|
|
return taEvList.GetByMacchinaPeriodo(idxMacchina, dal, al);
|
|
}
|
|
public DS_applicazione.DiarioDiBordoDataTable nextEventoImpiantoFrom(string idxMacchina, DateTime prevData)
|
|
{
|
|
return taDiario.getNextByMacchInizioStato(idxMacchina, prevData);
|
|
}
|
|
public DS_applicazione.DiarioDiBordoDataTable elencoStatiImpiantoPeriodo(string idxMacchina, DateTime dal, DateTime al)
|
|
{
|
|
DS_applicazione.DiarioDiBordoDataTable answ = new DS_applicazione.DiarioDiBordoDataTable();
|
|
try
|
|
{
|
|
answ = taDiario.GetByMacchinaPeriodo(idxMacchina, dal, al);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione recupero elencoStatiImpiantoPeriodo:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// verifica kanban valido
|
|
/// </summary>
|
|
/// <param name="codice"></param>
|
|
/// <returns></returns>
|
|
public bool isKanban(string codice)
|
|
{
|
|
return (taKanban.GetDataByKanbanMatrCode(codice).Rows.Count > 0);
|
|
}
|
|
/// <summary>
|
|
/// verifica se sia un nuovo kanban
|
|
/// </summary>
|
|
/// <param name="codice"></param>
|
|
/// <returns></returns>
|
|
public bool isNewKanban(string codice)
|
|
{
|
|
// controlli validità kanban
|
|
bool check = codice.StartsWith("K");
|
|
return check;
|
|
}
|
|
|
|
/// <summary> verifica che il bar code sia un barcode Operatore
|
|
/// </summary>
|
|
/// <param name="codice"> Bar code da verificare</param>
|
|
/// <returns> true se bar code per operatore </returns>
|
|
public bool isOperatore(string codice)
|
|
{
|
|
// controlli validità bar code operatore : deve cominciare con O maiuscola
|
|
bool check = codice.StartsWith("O");
|
|
return check;
|
|
}
|
|
|
|
/// <summary> verifica che il bar code sia un barcode nomeMacchina
|
|
/// </summary>
|
|
/// <param name="codice"> Bar code da verificare</param>
|
|
/// <returns> true se bar code per operatore </returns>
|
|
public bool isNomeMacchina(string codice)
|
|
{
|
|
// FARE!!! controllare quale codice ci vuole
|
|
// controlli validità bar code nomeMacchina : deve cominciare con O maiuscola
|
|
bool check = codice.StartsWith("C#");
|
|
return check;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// inserisce un nuovo kanban ignoto
|
|
/// </summary>
|
|
/// <param name="codice"></param>
|
|
/// <returns></returns>
|
|
public int insertUnknownKanban(string codice)
|
|
{
|
|
return taKanban.InsertUndefinedKanban(codice);
|
|
}
|
|
/// <summary>
|
|
/// verifica un codice se sia di tipo "comando"
|
|
/// </summary>
|
|
/// <param name="comando"></param>
|
|
/// <returns></returns>
|
|
public inputComando isComando(string comando)
|
|
{
|
|
inputComando answ = new inputComando();
|
|
answ.isValid = false;
|
|
DS_applicazione.TransizioneEventiDataTable tabTransEv = new DS_applicazione.TransizioneEventiDataTable();
|
|
try
|
|
{
|
|
tabTransEv = taTranEv.GetDataByCodInviato(comando);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
if (tabTransEv.Rows.Count != 0)
|
|
{
|
|
answ.isValid = true;
|
|
answ.idxTipoEvento = tabTransEv[0].IdxTipoEvento;
|
|
answ.precInput = tabTransEv[0].prec_codInviato;
|
|
answ.text2show = tabTransEv[0].text2show;
|
|
try
|
|
{
|
|
answ.descrComando = tabTransEv[0].descrComando;
|
|
}
|
|
catch
|
|
{
|
|
answ.descrComando = "-";
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce una riga di dati relativa ad una macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public DS_applicazione.StatoMacchineRow getRigaStatoMacchina(string idxMacchina)
|
|
{
|
|
return taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
|
|
}
|
|
/// <summary>
|
|
/// converte la definizioen di stato nel suo valore
|
|
/// </summary>
|
|
/// <param name="idx"></param>
|
|
/// <returns></returns>
|
|
public string statoDaIdxStato(int idx)
|
|
{
|
|
return taAnagSt.GetByIdx(idx)[0].Descrizione;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive un evento di keepalive sulla tabella
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="oraMacchina"></param>
|
|
/// <returns></returns>
|
|
public void scriviKeepAlive(string IdxMacchina, DateTime oraMacchina)
|
|
{
|
|
// salvo in variabile boolean se registrare keep alive su db o meno
|
|
bool doWrite = false;
|
|
string nomeVar = string.Format("KA{0}", IdxMacchina);
|
|
// in primis controllo se in cache c'è oggetto keep alive x macchina... formato KA{ID-MACCHINA}
|
|
if (memLayer.ML.isInCacheObject(nomeVar))
|
|
{
|
|
// leggo data ora, se è + vecchia di corrente - kaMinUpdSec segno da aggiornare
|
|
DateTime adesso = DateTime.Now;
|
|
DateTime lastKA = DateTime.Now;
|
|
try
|
|
{
|
|
lastKA = (DateTime)memLayer.ML.objCacheObj(nomeVar);
|
|
}
|
|
catch
|
|
{ }
|
|
if (adesso.AddSeconds(-memLayer.ML.CRI("kaMinUpdSec")) > lastKA)
|
|
{
|
|
doWrite = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// non c'è in sessione, lo salvo
|
|
memLayer.ML.setCacheVal(nomeVar, oraMacchina);
|
|
// indico di fare refresh
|
|
doWrite = true;
|
|
}
|
|
if (doWrite)
|
|
{
|
|
try
|
|
{
|
|
if (memLayer.ML.confReadBool("forceResetKeepAlive"))
|
|
{
|
|
taKeepAlive.Connection.Close();
|
|
taKeepAlive.Connection.Open();
|
|
}
|
|
else
|
|
{
|
|
if (taKeepAlive.Connection.State == ConnectionState.Closed)
|
|
{
|
|
taKeepAlive.Connection.Open();
|
|
}
|
|
}
|
|
taKeepAlive.UpdateQueryNoStartTime(DateTime.Now, oraMacchina, IdxMacchina);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in scrittura keep alive!{0}oraMacchina:{1} - IdxMacchina:{2}{0}{3}", Environment.NewLine, oraMacchina, IdxMacchina, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Registra un evento di RemoteReboot sulla tabella
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="IPv4"></param>
|
|
/// <param name="macAddr"></param>
|
|
/// <returns></returns>
|
|
public void scriviRemoteReboot(string IdxMacchina, string IPv4, string agent, string macAddr)
|
|
{
|
|
taRRL.Insert(IdxMacchina, IPv4, agent, DateTime.Now, macAddr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive un evento di start di keepalive sulla tabella
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="oraMacchina"></param>
|
|
/// <returns></returns>
|
|
public void scriviPrimoKeepAlive(string IdxMacchina, DateTime oraMacchina)
|
|
{
|
|
// se non c'è riga macchina insert...
|
|
if (taKeepAlive.GetData().FindByIdxMacchina(IdxMacchina) == null)
|
|
{
|
|
taKeepAlive.Insert(IdxMacchina, DateTime.Now, oraMacchina, DateTime.Now);
|
|
}
|
|
else // altrimenti update!
|
|
{
|
|
taKeepAlive.UpdateQuery(DateTime.Now, oraMacchina, DateTime.Now, IdxMacchina);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// fornisce il prossimo IdxMicroStato della macchina a stati della gestione segnali in input
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="IdxMicroStato"></param>
|
|
/// <param name="ValoreIngresso"></param>
|
|
/// <returns></returns>
|
|
public hwMachineState getNextMicroStato(string IdxMacchina, int IdxMicroStato, int ValoreIngresso)
|
|
{
|
|
hwMachineState valori = new hwMachineState();
|
|
valori.IdxTipoEvento = -1;
|
|
valori.next_IdxMicroStato = IdxMicroStato; // se non trovo un nuovo stato, resto in questo
|
|
// provo a recuperare i dati...
|
|
DS_applicazione.TransizioneIngressiRow rigaIngr;
|
|
try
|
|
{
|
|
rigaIngr = (DS_applicazione.TransizioneIngressiRow)(taTransIngr.GetNextStatus(IdxMacchina, IdxMicroStato, ValoreIngresso)[0]);
|
|
valori.IdxTipoEvento = rigaIngr.IdxTipoEvento;
|
|
valori.next_IdxMicroStato = rigaIngr.next_IdxMicroStato;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return valori;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce la stringa del colore della macchina (1 char, V/G/R)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string getColoreMacchina(string idxMacchina)
|
|
{
|
|
string colore = "";
|
|
// cerco stato macchina...
|
|
DS_applicazione.StatoMacchineRow rigaStato;
|
|
try
|
|
{
|
|
rigaStato = (DS_applicazione.StatoMacchineRow)(taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0]);
|
|
// cerco il colore...
|
|
try
|
|
{
|
|
colore = taAnagSt.GetByIdx(rigaStato.IdxStato)[0].Semaforo;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return colore;
|
|
}
|
|
/// <summary>
|
|
/// restituisce la stringa del pallet correntemente in lavorazione sulla macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string getPalletMacchina(string idxMacchina)
|
|
{
|
|
string pallet = "";
|
|
try
|
|
{
|
|
pallet = (taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0]).pallet;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return pallet;
|
|
}
|
|
/// <summary>
|
|
/// restituisce la matricola dell'operatore sulla macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public int getMatrOprMacchina(string idxMacchina)
|
|
{
|
|
return getMatrOpMacc(idxMacchina);
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce cognome nome dell'operatore data la sua matricola
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string getCognomeNomeDaMatr(int matrOpr)
|
|
{
|
|
return getGeneralitDaMatr(matrOpr);
|
|
}
|
|
/// <summary>
|
|
/// restituisce cognome nome dell'operatore data la sua matricola
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public string getCognomeNomeOprMacchina(string idxMacchina)
|
|
{
|
|
string cognNome = "";
|
|
try
|
|
{
|
|
cognNome = getGeneralitDaMatr(getMatrOpMacc(idxMacchina));
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return cognNome;
|
|
}
|
|
|
|
/// <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 = DataLayer.obj.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
|
|
logger.lg.scriviLog(string.Format("Impostato TC Tempo Ciclo a 99' (99.9M) causa mancato inserimento tempo ciclo dichiarato"));
|
|
}
|
|
return tc;
|
|
}
|
|
|
|
/// <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...
|
|
taDiario.DeleteByMacchinaPeriodo(IdxMacchina, dataInizio, dataFine);
|
|
// seleziono le righe eventi interessate e le processo 1 ad 1...
|
|
DS_applicazione.EventListDataTable tabEventi = 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.MatricolaKanban, rigaEv.Value, rigaEv.MatrOpr, rigaEv.pallet);
|
|
}
|
|
else // è hw
|
|
{
|
|
checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, rigaEv.InizioStato, rigaEv.IdxTipo, rigaEv.MatricolaKanban, rigaEv.Value, rigaEv.MatrOpr, rigaEv.pallet);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// restituisce la riga di transizione del comando...
|
|
/// </summary>
|
|
/// <param name="descrComando"></param>
|
|
/// <returns></returns>
|
|
public DS_applicazione.TransizioneEventiRow getRigaTransizioneDaDescrComando(string descrComando)
|
|
{
|
|
return taTranEv.getByDescrComando(descrComando)[0];
|
|
}
|
|
/// <summary>
|
|
/// restituisce il kanban (CodArticolo) dalla matricola
|
|
/// </summary>
|
|
/// <param name="matricola">codice univoco della matricola</param>
|
|
/// <returns>restituisce il kanban (eventualmente comune a più matricole...)</returns>
|
|
public string getKanbanDaMatr(string matricola)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = (taKanban.GetDataByKanbanMatrCode(matricola)[0]).KanbanCode;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Dichiara esplicitamente produzione e tempo ciclo rilevato per il numero di pezzi indicati (real time, NON confermati)
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <param name="CodArticolo"></param>
|
|
/// <param name="tempoRilevato"></param>
|
|
/// <param name="numPz"></param>
|
|
/// <param name="eventTime"></param>
|
|
/// <param name="currentTime"></param>
|
|
public void dichiaraProduzTempoCiclo(string IdxMacchina, string CodArticolo, decimal tempoRilevato, int numPz, DateTime eventTime, DateTime currentTime)
|
|
{
|
|
// calcolo dataOra reale (evento + delta(ora server - ora remota)
|
|
DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
|
|
// scrivo il dato del TC rilevato
|
|
taTCRilevati.Insert(IdxMacchina, CodArticolo, dataOra, tempoRilevato, numPz);
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua verifica del codice barcode e restituisce un oggetto inputComando che indica come proseguire
|
|
/// </summary>
|
|
/// <param name="barcodeValue"></param>
|
|
/// <returns></returns>
|
|
public inputComando tryBarcode(string barcodeValue)
|
|
{
|
|
inputComando answ = new inputComando();
|
|
// controllo...
|
|
|
|
return answ;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |