Samuele E. Locatelli
842 lines
26 KiB
C#
842 lines
26 KiB
C#
using MapoDb;
|
|
using Newtonsoft.Json;
|
|
using SteamWare;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Web.Mvc;
|
|
|
|
namespace MP_IO.Controllers
|
|
{
|
|
public class IOBController : Controller
|
|
{
|
|
// GET: IOB (è un check alive del server)
|
|
public string Index()
|
|
{
|
|
if (memLayer.ML.CRB("IOB_RedEnab"))
|
|
{
|
|
// conto la richiesta nel contatore REDIS
|
|
long nCall = memLayer.ML.setRCntI(DataLayer.mHash("COUNT:pCall:IOB_INDEX"));
|
|
//... se == nCall2Log scrivo su log e resetto
|
|
long nCall2Log = memLayer.ML.cdvi("nCall2Log");
|
|
if (nCall >= nCall2Log)
|
|
{
|
|
// loggo
|
|
logger.lg.scriviLog(string.Format("IOB_INDEX: effettuate {0} call", nCall), tipoLog.INFO);
|
|
// resetto!
|
|
memLayer.ML.resetRCnt(DataLayer.mHash("COUNT:pCall:IOB_INDEX"));
|
|
}
|
|
}
|
|
return "OK";
|
|
}
|
|
|
|
// GET: IOB/enabled/SIMUL_03
|
|
public string enabled(string id)
|
|
{
|
|
string answ = "ND";
|
|
// se id nullo --> KO!
|
|
if (id == null)
|
|
{
|
|
answ = "KO";
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
// salvo risposta!
|
|
answ = DataLayer.insEnab(id) ? "OK" : "NO";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in enabled{0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
// GET: IOB/slog/SIMUL_03
|
|
public string slog(string id)
|
|
{
|
|
string answ = "ND";
|
|
// se id nullo --> KO!
|
|
if (id == null)
|
|
{
|
|
answ = "KO";
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
answ = DataLayer.sLogEnab(id) ? "OK" : "NO";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in sLog{0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
// GET: IOB/input/SIMUL_03?valore=3&dtEve=20181206180600000&dtCurr=20181206180600000&cnt=999
|
|
public string input(string id, string valore, string dtEve, string dtCurr, string cnt)
|
|
{
|
|
string answ = "";
|
|
// formato yyyymmddHHMMSSnnn ovvero da anno a millisecondi
|
|
if (cnt == null)
|
|
{
|
|
cnt = "0";
|
|
}
|
|
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
if (memLayer.ML.CRI("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Valori letti:{0}idxMacchina: {1}{0}valore: {2}{0}dtEve: {3}{0}dtCurr: {4}{0}cnt: {5}", Environment.NewLine, id, valore, dtEve, dtCurr, cnt), tipoLog.INFO);
|
|
}
|
|
try
|
|
{
|
|
answ = DataLayer.processInput(id, valore, dtEve, dtCurr, cnt);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in processInput{0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
// GET: IOB/flog/SIMUL_03?flux=PROG&valore=P0001&dtEve=20161223180600000&dtCurr=20161223180600000&cnt=999
|
|
public string flog(string id, string flux, string valore, string dtEve, string dtCurr, string cnt)
|
|
{
|
|
string answ = "";
|
|
// formato yyyymmddHHMMSSnnn ovvero da anno a millisecondi
|
|
if (cnt == null)
|
|
{
|
|
cnt = "0";
|
|
}
|
|
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
if (memLayer.ML.CRI("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Valori letti:{0}idxMacchina: {1}{0}flux: {6}{0}valore: {2}{0}dtEve: {3}{0}dtCurr: {4}{0}cnt: {5}", Environment.NewLine, id, valore, dtEve, dtCurr, cnt, flux), tipoLog.INFO);
|
|
}
|
|
try
|
|
{
|
|
int count = 0;
|
|
Int32.TryParse(cnt, out count);
|
|
answ = DataLayer.processFluxLog(id, flux, valore, dtEve, dtCurr, count);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in flog{0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Processa una chiamata POST per l'invio di un array jSon di oggetti fluxLog
|
|
/// PUT: IOB/flogJson/SIMUL_03
|
|
/// </summary>
|
|
/// <param name="id">ID dell'IOB</param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public string flogJson(string id)
|
|
{
|
|
string answ = "-";
|
|
// questa calsse è derivata da Controller.Response... x cui recupero lo stream in altro modo...
|
|
string content = "";
|
|
System.Web.HttpContext.Current.Request.InputStream.Position = 0;
|
|
using (var reader = new StreamReader(
|
|
Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
|
|
{
|
|
content = reader.ReadToEnd();
|
|
}
|
|
//Rest
|
|
System.Web.HttpContext.Current.Request.InputStream.Position = 0;
|
|
// procedo a deserializzare in blocco l'oggetto...
|
|
try
|
|
{
|
|
// deserializzo.
|
|
flogJson receivedData = JsonConvert.DeserializeObject<flogJson>(content);
|
|
// per ogni valore --> salvo!
|
|
foreach (var item in receivedData.fluxData)
|
|
{
|
|
// formato datetime come yyyyMMddHHmmssfff -->es: 20181223180600000
|
|
answ = DataLayer.processFluxLog(id, item.flux, item.valore, item.dtEve.ToString("yyyyMMddHHmmssfff"), item.dtCurr.ToString("yyyyMMddHHmmssfff"), item.cnt);
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Processa una chiamata POST per l'invio di un array jSon di oggetti LIVE REC
|
|
/// PUT: IOB/liveJson/SIMUL_03
|
|
/// </summary>
|
|
/// <param name="id">ID dell'IOB</param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public string liveJson(string id)
|
|
{
|
|
string answ = "-";
|
|
// questa calsse è derivata da Controller.Response... x cui recupero lo stream in altro modo...
|
|
string content = "";
|
|
System.Web.HttpContext.Current.Request.InputStream.Position = 0;
|
|
using (var reader = new StreamReader(
|
|
Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
|
|
{
|
|
content = reader.ReadToEnd();
|
|
}
|
|
//Rest
|
|
System.Web.HttpContext.Current.Request.InputStream.Position = 0;
|
|
// procedo a deserializzare in blocco l'oggetto...
|
|
try
|
|
{
|
|
// deserializzo.
|
|
liveIOB receivedData = JsonConvert.DeserializeObject<liveIOB>(content);
|
|
answ = DataLayer.processLiveJson(id, receivedData);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Errore in liveJson{Environment.NewLine}{exc}");
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Processa una chiamata POST per l'invio di un file "a nome" di un IOB
|
|
/// PUT: IOB/uploadFile/SIMUL_03
|
|
/// </summary>
|
|
/// <param name="id">ID dell'IOB</param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public string uploadFile(string id)
|
|
{
|
|
string answ = "-";
|
|
// questa calsse è derivata da Controller.Response... x cui recupero lo stream in altro modo...
|
|
string content = "";
|
|
System.Web.HttpContext.Current.Request.InputStream.Position = 0;
|
|
using (var reader = new StreamReader(Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
|
|
{
|
|
content = reader.ReadToEnd();
|
|
}
|
|
//Rest
|
|
System.Web.HttpContext.Current.Request.InputStream.Position = 0;
|
|
// procedo a deserializzare in blocco l'oggetto...
|
|
try
|
|
{
|
|
// deserializzo.
|
|
smallFile receivedData = JsonConvert.DeserializeObject<smallFile>(content);
|
|
// salvo nella cartella di Upload...
|
|
string basePath = Server.MapPath(memLayer.ML.CRS("uploadFileDir"));
|
|
string dirPath = $"{basePath}\\{id}";
|
|
// fix directory...
|
|
Directory.CreateDirectory(dirPath);
|
|
// scrivo!
|
|
System.IO.File.WriteAllText($"{dirPath}\\{receivedData.fileName}", receivedData.content);
|
|
answ = "OK";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Errore in uploadFile{Environment.NewLine}{exc}");
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce un array JSon di files di una IOB
|
|
/// PUT: IOB/getFiles/SIMUL_03
|
|
/// </summary>
|
|
/// <param name="id">ID dell'IOB</param>
|
|
/// <returns></returns>
|
|
public string getFiles(string id)
|
|
{
|
|
string answ = "[]";
|
|
|
|
// procedo a deserializzare in blocco l'oggetto...
|
|
try
|
|
{
|
|
// recupero TUTTI i fiels della folder dell'IOB richiesta
|
|
string basePath = Server.MapPath(memLayer.ML.CRS("uploadFileDir"));
|
|
string dirPath = $"{basePath}\\{id}";
|
|
var fileList = fileMover.obj.elencoFilesDir(dirPath);
|
|
List<smallFile> list4send = new List<smallFile>();
|
|
smallFile currFile = null;
|
|
string fileContent = "";
|
|
foreach (var item in fileList)
|
|
{
|
|
fileContent = System.IO.File.ReadAllText($"{dirPath}\\{item.Nome}");
|
|
currFile = new smallFile()
|
|
{
|
|
fileName = item.Nome,
|
|
content = fileContent.Replace("\n",Environment.NewLine)
|
|
};
|
|
list4send.Add(currFile);
|
|
}
|
|
// serializzo
|
|
answ = JsonConvert.SerializeObject(list4send);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Errore in uploadFile{Environment.NewLine}{exc}");
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
// GET: IOB/liveRec/SIMUL_03?&liveData=chiave1|valore1#chiave2|valore#|chiave3|valore3
|
|
public string liveRec(string id, string liveData)
|
|
{
|
|
string answ = "";
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
if (memLayer.ML.CRI("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog($"Valori Live:{Environment.NewLine}idxMacchina: {id}{Environment.NewLine}liveData: {liveData}", tipoLog.INFO);
|
|
}
|
|
try
|
|
{
|
|
answ = DataLayer.processLiveRec(id, liveData);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Errore in liveRec{Environment.NewLine}{exc}");
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Recupera ODL corrente x macchina:
|
|
///
|
|
/// GET: IOB/getCurrODL/SIMUL_03
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string getCurrODL(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = DataLayer.currODL(id).ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in currODL (get){0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce data-ora inizio dell'odl correntemente in lavorazione sulla macchina...
|
|
/// es: http://url_site/MP/IO/IOB/getCurrOdlStart/SIMUL_03
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string getCurrOdlStart(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
DateTime answ = new DateTime(DateTime.Now.Year - 1, 12, 31);
|
|
// chiamo metodo redis/db...
|
|
try
|
|
{
|
|
DS_ProdTempi.ODLDataTable currTab = DataLayer.currODLRowTab(id);
|
|
if (currTab.Count > 0)
|
|
{
|
|
DS_ProdTempi.ODLRow odlRow = currTab[0];
|
|
answ = odlRow.DataInizio;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Eccezione in recupero getCurrOdlStart{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ.ToString("yyyy-MM-dd HH:mm:ss");
|
|
}
|
|
/// <summary>
|
|
/// Restituisce intera riga dell'odl correntemente in lavorazione sulla macchina...
|
|
/// GET: IOB/getCurrOdlRow/SIMUL_01
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string getCurrOdlRow(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
string answ = "";
|
|
DS_ProdTempi.ODLDataTable currData = null;
|
|
// chiamo metodo redis/db...
|
|
try
|
|
{
|
|
currData = DataLayer.currODLRowTab(id);
|
|
answ = JsonConvert.SerializeObject(currData);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Eccezione in recupero getCurrOdlRow{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce intera riga dello stato di macchina...
|
|
/// GET: IOB/getCurrStatoRow/SIMUL_01
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string getCurrStatoRow(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
string answ = "";
|
|
DS_applicazione.StatoMacchineDataTable currData = null;
|
|
// chiamo metodo redis/db...
|
|
try
|
|
{
|
|
currData = DataLayer.currSMTab(id);
|
|
answ = JsonConvert.SerializeObject(currData);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Eccezione in recupero getCurrStatoRow{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce il valore dello stato di IDLE della macchina, quindi SOLO SE NON é in lavoro e già convertito in minuti...
|
|
/// GET: IOB/getIdlePeriod/SIMUL_01
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public int getIdlePeriod(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
int answ = 0;
|
|
DS_applicazione.StatoMacchineDataTable currData = null;
|
|
// chiamo metodo redis/db...
|
|
try
|
|
{
|
|
currData = DataLayer.currSMTab(id);
|
|
if (currData.Count > 0)
|
|
{
|
|
// recupero da redis elenco stati
|
|
DS_applicazione.AnagraficaStatiDataTable anagStati = DataLayer.AnagraficaStati();
|
|
DS_applicazione.AnagraficaStatiRow currStato = anagStati.FindByIdxStato(currData[0].IdxStato);
|
|
// calcolo SE sia idle... OVVERO SEMAFORO NON VERDE!!!
|
|
if (currStato.Semaforo != "sVe")
|
|
{
|
|
// calcolo durata...
|
|
answ = (int)DateTime.Now.Subtract(currData[0].InizioStato).TotalMinutes;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Eccezione in recupero getIdlePeriod{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Recupera DATI correnti x macchina:
|
|
///
|
|
/// GET: IOB/getCurrData/SIMUL_03
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>jSon contenente la riga di stato macchina</returns>
|
|
public string getCurrData(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
// recupero dati macchina...
|
|
Dictionary<string, string> valori = DataLayer.mDatiMacchine(id);
|
|
answ = JsonConvert.SerializeObject(valori);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Chiude ODL precedente ed avvia uno nuovo (duplicandolo)
|
|
///
|
|
/// GET: IOB/forceSplitOdl/SIMUL_03
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>jSon contenente la riga di stato macchina</returns>
|
|
public string forceSplitOdl(string id)
|
|
{
|
|
// attenzione! poiché nell'URL il carattere "#" fiene filtrato ci aspettiamo il carattere "|" che poi trasformiamo ora in "#"
|
|
id = id.Replace("|", "#");
|
|
return DataLayer.forceSplitOdl(id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera TASK richiesto x macchina:
|
|
///
|
|
/// GET: IOB/getTask2Exe/SIMUL_03
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>jSon contenente 1..n task da eseguire</returns>
|
|
public string getTask2Exe(string id)
|
|
{
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
// leggo da REDIS eventuale elenco task x macchina...
|
|
Dictionary<string, string> valori = DataLayer.mTaskMacchina(id);
|
|
answ = JsonConvert.SerializeObject(valori);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// AGGIUNGE TASK richiesto x macchina:
|
|
///
|
|
/// GET: IOB/addTask2Exe/3010?taskName=startSetup&taskVal=T190406101512
|
|
/// GET: IOB/addTask2Exe/3010?taskName=stopSetup&taskVal=T190406101512
|
|
/// GET: IOB/addTask2Exe/SIMUL_03?taskName=setProg&taskVal=P00000001
|
|
/// GET: IOB/addTask2Exe/SIMUL_03?taskName=setComm&taskVal=ODL_0000123
|
|
/// GET: IOB/addTask2Exe/SIMUL_03?taskName=setArt&taskVal=ART_0000321
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="taskName"></param>
|
|
/// <param name="taskVal"></param>
|
|
public string addTask2Exe(string id, string taskName, string taskVal)
|
|
{
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
// converto stringa in tipo task...
|
|
taskType tName = taskType.nihil;
|
|
bool fatto = Enum.TryParse(taskName, out tName);
|
|
if (fatto)
|
|
{
|
|
DataLayer.addTask4Machine(id, tName, taskVal);
|
|
}
|
|
else
|
|
{
|
|
logger.lg.scriviLog($"addTask2Exe: impossibile riconoscere il comando {taskName} come uno deitipi ammessi, NON aggiunto", tipoLog.ERROR);
|
|
}
|
|
answ = getTask2Exe(id);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// ELIMINA TASK richiesto x macchina:
|
|
///
|
|
/// GET: IOB/remTask2Exe/SIMUL_03?taskName=T180326160502
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="taskName"></param>
|
|
public string remTask2Exe(string id, string taskName)
|
|
{
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
// converto stringa in tipo task...
|
|
taskType tName = taskType.nihil;
|
|
bool fatto = Enum.TryParse(taskName, out tName);
|
|
if (fatto)
|
|
{
|
|
DataLayer.remTask4Machine(id, tName);
|
|
}
|
|
else
|
|
{
|
|
logger.lg.scriviLog($"remTask2Exe: impossibile riconoscere il comando {taskName} come uno deitipi ammessi, NON aggiunto", tipoLog.ERROR);
|
|
}
|
|
answ = getTask2Exe(id);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Recupera TASK richiesto x macchina:
|
|
///
|
|
/// GET: IOB/getOptPar/SIMUL_03
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>jSon contenente 1..n task da eseguire</returns>
|
|
public string getOptPar(string id)
|
|
{
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
// leggo da REDIS eventuale elenco task x macchina...
|
|
Dictionary<string, string> valori = DataLayer.mOptParMacchina(id);
|
|
answ = JsonConvert.SerializeObject(valori);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// SALVA x macchina KVP parametro/valore:
|
|
///
|
|
/// GET: IOB/addOptPar/SIMUL_03?pName=PZREQ&pValue=1000
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="pName"></param>
|
|
/// <param name="pValue"></param>
|
|
public string addOptPar(string id, string pName, string pValue)
|
|
{
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
DataLayer.addOptPar4Machine(id, pName, pValue);
|
|
answ = getOptPar(id);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// ELIMINA TASK richiesto x macchina:
|
|
///
|
|
/// GET: IOB/remOptPar/SIMUL_03?pName=PZREQ
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="pName"></param>
|
|
public string remOptPar(string id, string pName)
|
|
{
|
|
string answ = "";
|
|
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
|
|
MapoDb.MapoDb connDb = new MapoDb.MapoDb();
|
|
connDb.scriviKeepAlive(id, DateTime.Now);
|
|
try
|
|
{
|
|
DataLayer.remOptPar4Machine(id, pName);
|
|
answ = getOptPar(id);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Effettua RESET dell'ODL corrente x macchina:
|
|
///
|
|
/// GET: IOB/resetCurrODL/5
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string resetCurrODL(string id)
|
|
{
|
|
return DataLayer.emptyCurrODL(id);
|
|
}
|
|
/// <summary>
|
|
/// Recupera COUNTER x macchina:
|
|
///
|
|
/// GET: IOB/getCounter/5
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string getCounter(string id)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = DataLayer.pzCounter(id).ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in counter (get){0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Recupera COUNTER x macchina dal CONTEGGIO dei TCRecorded:
|
|
///
|
|
/// GET: IOB/getCounterTCRec/5
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public string getCounterTCRec(string id)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = DataLayer.pzCounterTC(id).ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in counter TC (get){0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// SALVA Counter x macchina:
|
|
///
|
|
/// GET: IOB/setCounter/5?counter=10
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="counter"></param>
|
|
/// <returns></returns>
|
|
public string setCounter(string id, string counter)
|
|
{
|
|
string answ = "";
|
|
DateTime dataOraEvento = DateTime.Now;
|
|
if (memLayer.ML.CRI("_logLevel") > 6)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Salvataggio counter:{0}idxMacchina: {1}{0}conteggio: {2}", Environment.NewLine, id, counter), tipoLog.INFO);
|
|
}
|
|
try
|
|
{
|
|
answ = DataLayer.saveCounter(id, counter);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in counter (set){0}{1}", Environment.NewLine, exc));
|
|
answ = "NO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Salva associazione tra macchina, device IOB chiamante e sue info
|
|
/// </summary>
|
|
/// <param name="id">Id della macchina</param>
|
|
/// <param name="IOB_name">Nome dell'IOB di acquisizione della macchina</param>
|
|
/// <returns></returns>
|
|
public string setM2IOB(string id, string IOB_name)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
// recupero IP del client remoto
|
|
string IPv4 = Request.UserHostName;
|
|
string agent = Request.UserAgent;
|
|
// creo oggetto IOB_data...
|
|
IOB_data m2IOB = new IOB_data
|
|
{
|
|
name = IOB_name,
|
|
IP = IPv4,
|
|
iType = IobType.ND,
|
|
typeCss = "fa fa-question-circle-o",
|
|
CNC_Counter = false
|
|
};
|
|
// imposto tipo ed icona come windows/linux secondo UserAgent...
|
|
if (agent.IndexOf("WIN") >= 0)
|
|
{
|
|
m2IOB.iType = IobType.WIN;
|
|
m2IOB.typeCss = "fa fa-windows";
|
|
m2IOB.CNC_Counter = true;
|
|
}
|
|
else if (agent.IndexOf("Python") >= 0)
|
|
{
|
|
m2IOB.iType = IobType.rPi;
|
|
m2IOB.typeCss = "fa fa-linux";
|
|
}
|
|
// serializzo...
|
|
string dataSer = JsonConvert.SerializeObject(m2IOB);
|
|
// salvo in redis...
|
|
string hM2IOB = DataLayer.hM2IOB(id);
|
|
memLayer.ML.setRSV(hM2IOB, dataSer);
|
|
// salvo tutto OK
|
|
answ = "OK";
|
|
}
|
|
catch
|
|
{
|
|
answ = "KO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce dati di associazione tra macchina, device IOB chiamante e sue info
|
|
/// </summary>
|
|
/// <param name="id">Id della macchina</param>
|
|
/// <returns></returns>
|
|
public string getM2IOB(string id)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
// recupero da redis...
|
|
string hM2IOB = DataLayer.hM2IOB(id);
|
|
string dataSer = memLayer.ML.getRSV(hM2IOB);
|
|
if (dataSer != "" && dataSer != null)
|
|
{
|
|
// restituisco jSon
|
|
answ = dataSer;
|
|
}
|
|
else
|
|
{
|
|
answ = "NO";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
answ = "KO";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce il (primo) codice IOB da dover gestire (se un IOBMAN chiede di gestirne uno in +...)
|
|
/// </summary>
|
|
/// <param name="GWIP">IP del Gateway</param>
|
|
/// <returns></returns>
|
|
public string getIob2call(string GWIP)
|
|
{
|
|
string answ = "";
|
|
|
|
// !!!FARE!!! temporanemanete genera a caso vuoto o 3000 x permettere test... altrimenti gestisce VERA coda... secondi pari...
|
|
int resto = 0;
|
|
Math.DivRem(DateTime.Now.Second, 2, out resto);
|
|
if (resto == 0)
|
|
{
|
|
answ = "3000";
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Salva IP del gateway dopo il reboot
|
|
/// </summary>
|
|
/// <param name="GWIP">IP del Gateway</param>
|
|
/// <returns></returns>
|
|
public string sendRebootGateway(string GWIP)
|
|
{
|
|
string answ = "OK";
|
|
|
|
// !!!FARE!!! deve salvare il riavvio dell'applicazione GATEWAY multiclient
|
|
|
|
return answ;
|
|
}
|
|
|
|
}
|
|
} |