zaccaria.majid
468 lines
18 KiB
C#
468 lines
18 KiB
C#
using EgwCoreLib.Razor;
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.AspNetCore.Components.Forms;
|
|
using Microsoft.AspNetCore.Mvc.RazorPages;
|
|
using Microsoft.Extensions.ObjectPool;
|
|
using Org.BouncyCastle.Utilities;
|
|
using SMGen.Data;
|
|
using SMGen.Data.DbModels;
|
|
using SMGen.Data.Services;
|
|
using System.Text;
|
|
|
|
namespace SMGen.Pages
|
|
{
|
|
public partial class SMIn2Event
|
|
{
|
|
protected SelectSMIn2EvParams currFilter = new SelectSMIn2EvParams();
|
|
|
|
protected DataPager? pagerSMIn2Ev = null!;
|
|
protected bool b_rules_definition { get; set; } = false;
|
|
|
|
protected List<string> Bits { get; set; } = new List<string>();
|
|
|
|
[Inject]
|
|
protected IConfiguration conf { get; set; } = null!;
|
|
|
|
[Inject]
|
|
protected IWebHostEnvironment env { get; set; } = null!;
|
|
|
|
[Inject]
|
|
protected SMGDataService SMGDService { get; set; } = null!;
|
|
|
|
protected List<string> Events_to_send { get; set; } = new List<string>();
|
|
protected List<AnagEventiModelTemp> events2Add { get; set; } = new List<AnagEventiModelTemp>();
|
|
|
|
protected List<string> fileLines { get; set; } = new List<string>();
|
|
|
|
//protected Dictionary<string, string> files2Download { get; set; } = new Dictionary<string, string>();
|
|
|
|
//protected Dictionary<string, bool> filesStatus { get; set; } = new Dictionary<string, bool>();
|
|
private Dictionary<string, bool> filesStatus
|
|
{
|
|
get => currFilter.FilesStatus;
|
|
set => currFilter.FilesStatus = value;
|
|
}
|
|
private Dictionary<string, string> files2Download
|
|
{
|
|
get => currFilter.Files2Download;
|
|
set => currFilter.Files2Download = value;
|
|
}
|
|
|
|
protected Dictionary<string, string> files2Read { get; set; } = new Dictionary<string, string>();
|
|
|
|
protected List<TransizioneIngressiModelTemp> TranInList2add { get; set; } = new List<TransizioneIngressiModelTemp>();
|
|
|
|
protected int n_bits { get; set; } = 0;
|
|
|
|
protected string n_state_machine_index { get; set; } = "";
|
|
|
|
protected int n_states { get; set; } = 0;
|
|
|
|
protected string pathDir { get; set; } = "";
|
|
|
|
protected string pathFile { get; set; } = "";
|
|
|
|
protected string procRootDir
|
|
{
|
|
get => conf.GetValue<string>("ServerConf:ProcCsvRootPath");
|
|
}
|
|
protected string bitCsvPath
|
|
{
|
|
get => conf.GetValue<string>("ServerConf:BitCsvPath");
|
|
}
|
|
|
|
protected List<RuleClass> Rules { get; set; } = new List<RuleClass>();
|
|
protected List<string> States { get; set; } = new List<string>();
|
|
//protected string sz_file2Read { get; set; } = "D:\\Repo\\Mapo-IOB\\StateMachine\\_DEFAULT\\60_STD_MACHINE.rul";
|
|
protected string sz_file2Read { get; set; } = "";
|
|
|
|
protected string sz_file2Write { get; set; } = "prova.csv";
|
|
protected string sz_state_machine_name { get; set; } = "";
|
|
protected bool checkDirExist(string dir)
|
|
{
|
|
bool answ = false;
|
|
var dirEx = Directory.Exists(dir);
|
|
if (dirEx)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
var dirCreate = Directory.CreateDirectory(dir);
|
|
if (dirCreate != null)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
answ = false;
|
|
}
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
|
|
|
|
protected async Task Read_rule_file_transitions()
|
|
{
|
|
foreach (var item in files2Read)
|
|
{
|
|
//await Task.Delay(10);
|
|
sz_state_machine_name = "";
|
|
n_state_machine_index = "";
|
|
n_states = 0;
|
|
n_bits = 0;
|
|
States.Clear();
|
|
Bits.Clear();
|
|
Events_to_send.Clear();
|
|
Rules.Clear();
|
|
sz_file2Read = item.Value;
|
|
|
|
using (StreamReader sr = new StreamReader(sz_file2Read))
|
|
{
|
|
string line = "";
|
|
while ((line = await sr.ReadLineAsync().ConfigureAwait(false)) != null)
|
|
{
|
|
if (!line.StartsWith("#") && !string.IsNullOrEmpty(line))
|
|
{
|
|
var sz_tokens = line.Split(":");
|
|
|
|
var sz_temp = sz_tokens[0].Trim();
|
|
switch (sz_temp)
|
|
{
|
|
case "$DEFINITIONS":
|
|
b_rules_definition = false;
|
|
break;
|
|
|
|
case "$NAME":
|
|
sz_state_machine_name = sz_tokens[1].Trim();
|
|
break;
|
|
|
|
case "$IDX":
|
|
n_state_machine_index = sz_tokens[1].Trim();
|
|
break;
|
|
|
|
case "$N_STATES":
|
|
n_states = int.Parse(sz_tokens[1].Trim());
|
|
break;
|
|
|
|
case "$N_BITS":
|
|
n_bits = int.Parse(sz_tokens[1].Trim());
|
|
break;
|
|
|
|
case "$BIT":
|
|
Bits.Add(sz_tokens[2].Trim().ToUpper());
|
|
break;
|
|
|
|
case "$STATE":
|
|
States.Add(sz_tokens[2].Trim().ToUpper());
|
|
break;
|
|
|
|
case "$EVENT":
|
|
Events_to_send.Add(sz_tokens[2].Trim().ToUpper());
|
|
var newEvent = new AnagEventiModelTemp()
|
|
{
|
|
IdxTipo = int.Parse(sz_tokens[1].Trim().ToUpper()),
|
|
Nome = sz_tokens[2].Trim().ToUpper()
|
|
};
|
|
|
|
events2Add.Add(newEvent);
|
|
break;
|
|
|
|
case "$RULES":
|
|
b_rules_definition = true;
|
|
break;
|
|
|
|
case "$DO":
|
|
b_rules_definition = false;
|
|
var isOk = checkDirExist(procRootDir);
|
|
if (isOk)
|
|
{
|
|
var fileName = $"{item.Key.Split(".")[0]}.csv";
|
|
evaluate_transitions($"{Path.Combine(procRootDir, bitCsvPath, fileName)}", item.Key);
|
|
await SMGDService.AnagEventinInsert(events2Add);
|
|
await Task.Delay(1);
|
|
filesStatus[item.Key] = await SMGDService.TranInInsert(TranInList2add, int.Parse(n_state_machine_index));
|
|
|
|
|
|
if (!files2Download.ContainsKey(item.Key))
|
|
{
|
|
files2Download.Add(item.Key, sz_file2Write);
|
|
}
|
|
await InvokeAsync(() => StateHasChanged());
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (b_rules_definition)
|
|
{
|
|
var temp_rule = new RuleClass()
|
|
{
|
|
state = sz_temp.Trim().ToUpper(),
|
|
expression = sz_tokens[1].Trim().ToUpper(),
|
|
next_state = sz_tokens[2].Trim().ToUpper(),
|
|
event_to_send = sz_tokens[3].Trim().ToUpper()
|
|
};
|
|
|
|
Rules.Add(temp_rule);
|
|
}
|
|
break;
|
|
}
|
|
|
|
//fileLines.Add(lineSplit[0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
protected async void evaluate_transitions(string sz_file2Write, string origFileName)
|
|
{
|
|
TranInList2add.Clear();
|
|
//events2Add.Clear();
|
|
|
|
if (File.Exists(sz_file2Write))
|
|
{
|
|
File.Delete(sz_file2Write);
|
|
}
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
|
|
sb.AppendLine("IdxFamigliaIngresso;IdxMicroStato;ValoreIngresso;IdxTipoEvento;next_IdxMicroStato");
|
|
string sz_actual_state = "";
|
|
string sz_actual_bit = "";
|
|
string sz_line = "";
|
|
//int i = 0;
|
|
int n_input = 0;
|
|
//int n = 0;
|
|
int n_mask = 0;
|
|
int n_bit = 0;
|
|
|
|
bool[] b_bit = new bool[20];
|
|
bool b_invert = false;
|
|
//ciclo negli stati
|
|
try
|
|
{
|
|
for (var i = 0; i <= n_states - 1; i++)
|
|
{
|
|
sz_actual_state = States.ToArray()[i];
|
|
|
|
//ciclo negli ingressi
|
|
for (n_input = 0; n_input <= (Math.Pow(2, n_bits) - 1); n_input++)
|
|
{
|
|
n_mask = 1;
|
|
for (var n = 0; n <= n_bits - 1; n++)
|
|
{
|
|
b_bit[n] = Convert.ToBoolean(n_input & n_mask);
|
|
n_mask = n_mask << 1;
|
|
}
|
|
|
|
var exitFor = false;
|
|
|
|
foreach (var act_rule in Rules)
|
|
{
|
|
n_bit = -1;
|
|
if ((act_rule.state == "ALL_STATES") || (act_rule.state == sz_actual_state))
|
|
{
|
|
//DA RESETTARE A FALSE (errore da principianti...)
|
|
b_invert = false;
|
|
|
|
sz_actual_bit = act_rule.expression;
|
|
|
|
//controllo se la riga contiene l'istruzione per negare il bit
|
|
if (sz_actual_bit.Trim().StartsWith("NOT"))
|
|
{
|
|
//inverto il bit
|
|
b_invert = true;
|
|
sz_actual_bit = sz_actual_bit.Replace("NOT ", "").Trim();
|
|
}
|
|
//cerca il nome del bit e ne trova l' indice da 0
|
|
n_bit = Bits.FindIndex(x => x == sz_actual_bit);
|
|
|
|
if (n_bit == -1)
|
|
{
|
|
exitFor = true;
|
|
}
|
|
|
|
int nextState = States.IndexOf(act_rule.next_state);
|
|
|
|
if (!exitFor)
|
|
{
|
|
if (((!b_invert) && b_bit[n_bit]) || (b_invert && (!b_bit[n_bit])))
|
|
{
|
|
sz_line = "";
|
|
//eseguo solo se diverso dallo stato corrente
|
|
if (States.IndexOf(act_rule.next_state) != i)
|
|
{
|
|
if (nextState < 0)
|
|
{
|
|
nextState = 0;
|
|
}
|
|
|
|
sz_line = $"{n_state_machine_index}" +
|
|
$";" +
|
|
$"{i}" +
|
|
$";" +
|
|
$"{n_input}" +
|
|
$";" +
|
|
$"{Events_to_send.IndexOf(act_rule.event_to_send)}" +
|
|
$";" +
|
|
$"{nextState}";
|
|
|
|
sb.AppendLine(sz_line);
|
|
|
|
var newTranIn = new TransizioneIngressiModelTemp()
|
|
{
|
|
IdxFamigliaIngresso = int.Parse(n_state_machine_index),
|
|
IdxMicroStato = i,
|
|
ValoreIngresso = n_input,
|
|
IdxTipoEvento = Events_to_send.IndexOf(act_rule.event_to_send),
|
|
next_IdxMicroStato = States.IndexOf(act_rule.next_state)
|
|
};
|
|
|
|
TranInList2add.Add(newTranIn);
|
|
}
|
|
exitFor = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
using (StreamWriter sw = new StreamWriter(sz_file2Write))
|
|
{
|
|
sw.Write(sb.ToString());
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
filesStatus[origFileName] = false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Procedee a bonificare la cartella di upload dei files + vecchi di 3 mesi
|
|
/// </summary>
|
|
private void deleteOldFiles(string dirPath)
|
|
{
|
|
// elenco files nella directory
|
|
string[] files = Directory.GetFiles(dirPath);
|
|
// li guardo tutti e se vecchi li elimino...
|
|
foreach (string file in files)
|
|
{
|
|
FileInfo fi = new FileInfo(file);
|
|
if (fi.LastAccessTime < DateTime.Now.AddMinutes(-20))
|
|
{
|
|
fi.Delete();
|
|
}
|
|
}
|
|
}
|
|
private int totalCount
|
|
{
|
|
get => currFilter.TotCount;
|
|
set => currFilter.TotCount = value;
|
|
}
|
|
private int numRecord
|
|
{
|
|
get => currFilter.NumRec;
|
|
set => currFilter.NumRec = value;
|
|
}
|
|
private int currPage
|
|
{
|
|
get => currFilter.CurrPage;
|
|
set => currFilter.CurrPage = value;
|
|
}
|
|
protected void UpdateTotCount(int newTotCount)
|
|
{
|
|
totalCount = newTotCount;
|
|
}
|
|
protected async Task updateFilter(SelectSMIn2EvParams newParams)
|
|
{
|
|
await Task.Delay(1);
|
|
currPage = 1;
|
|
// salvo comunque filtro reparto x utente
|
|
await Task.Delay(1);
|
|
await InvokeAsync(() => StateHasChanged());
|
|
currFilter = newParams;
|
|
}
|
|
|
|
protected async Task pgResetReq(bool doReset)
|
|
{
|
|
if (doReset)
|
|
{
|
|
await Task.Delay(1);
|
|
if (pagerSMIn2Ev != null)
|
|
{
|
|
pagerSMIn2Ev.resetCurrPage();
|
|
}
|
|
}
|
|
}
|
|
|
|
//// va dopo
|
|
//private StreamWriter objWriter { get; set; };
|
|
private async Task LoadFiles(InputFileChangeEventArgs e)
|
|
{
|
|
List<IBrowserFile> loadedFiles = new();
|
|
long maxFileSize = 1024 * 15;
|
|
int maxAllowedFiles = 150;
|
|
loadedFiles.Clear();
|
|
filesStatus.Clear();
|
|
files2Read.Clear();
|
|
|
|
foreach (var file in e.GetMultipleFiles(maxAllowedFiles))
|
|
{
|
|
try
|
|
{
|
|
loadedFiles.Add(file);
|
|
|
|
//assegno un nome file randomico x sicurezza
|
|
var trustedFileNameForFileStorage = Path.GetRandomFileName();
|
|
|
|
//path del file da scrivere
|
|
pathFile = Path.Combine(env.ContentRootPath,
|
|
env.EnvironmentName, "unsafe_uploads",
|
|
trustedFileNameForFileStorage);
|
|
|
|
//path cartella root (development)
|
|
pathDir = Path.Combine(env.ContentRootPath,
|
|
env.EnvironmentName, "unsafe_uploads");
|
|
|
|
//se la cartella non esiste, creo
|
|
if (!Directory.Exists(pathDir))
|
|
{
|
|
Directory.CreateDirectory(pathDir);
|
|
}
|
|
else
|
|
{
|
|
}
|
|
|
|
//creo file
|
|
await using FileStream fs = new(pathFile, FileMode.Create);
|
|
|
|
//copio il contenuto del file
|
|
await file.OpenReadStream(maxFileSize).CopyToAsync(fs);
|
|
if (file.Name.Contains(".rul"))
|
|
{
|
|
files2Read.Add(file.Name, pathFile);
|
|
filesStatus.Add(file.Name, false);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
protected void ForceReload(int newNum)
|
|
{
|
|
numRecord = newNum;
|
|
}
|
|
|
|
protected void ForceReloadPage(int newNum)
|
|
{
|
|
currPage = newNum;
|
|
}
|
|
}
|
|
} |