Samuele Locatelli
615 lines
21 KiB
C#
615 lines
21 KiB
C#
using GWMS.Data.DatabaseModels;
|
|
using GWMS.Data.DTO;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace GWMS.Data.Controllers
|
|
{
|
|
public class GWMSController : IDisposable
|
|
{
|
|
#region Private Fields
|
|
|
|
private static IConfiguration _configuration;
|
|
private static GWMSContext dbCtx;
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public GWMSController(IConfiguration configuration)
|
|
{
|
|
_configuration = configuration;
|
|
dbCtx = new GWMSContext(configuration);
|
|
Log.Info("Avviata classe GWMSController");
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Private Methods
|
|
|
|
private void CreateSimData(int numDays, int stepMin, int maxHourRate)
|
|
{
|
|
ResetController();
|
|
// generazione dati casuale
|
|
Random rnd = new Random();
|
|
foreach (var plant in GetPlants())
|
|
{
|
|
var currPlant = GetPlant(plant.PlantId);
|
|
// imposto limiti e valori attuali...
|
|
//currPlant.LevelMax = rnd.Next(24, 28) * 1000;
|
|
int simLevel = rnd.Next(1, (int)currPlant.LevelMax);
|
|
double simPress = (double)rnd.Next((int)(currPlant.PressMax - 50) * 10, (int)currPlant.PressMax * 10) / 10;
|
|
double simPressH = (double)rnd.Next((int)(currPlant.PressBHMax - 70) * 10, (int)currPlant.PressBHMax * 10) / 10;
|
|
double simPressL = (double)rnd.Next((int)(currPlant.PressBLMax - 70) * 10, (int)currPlant.PressBLMax * 10) / 10;
|
|
currPlant.LevelAct = simLevel;
|
|
currPlant.PressAct = simPress;
|
|
currPlant.PressBHAct = simPressH;
|
|
currPlant.PressBLAct = simPressL;
|
|
dbCtx.SaveChanges();
|
|
|
|
// genero random le soglie x simulare rilievi e ordini
|
|
int soglia01 = rnd.Next((int)currPlant.LevelMax * 60 / 100, (int)currPlant.LevelMax * 75 / 100);
|
|
int soglia02 = rnd.Next((int)currPlant.LevelMax * 5 / 100, (int)currPlant.LevelMax * 35 / 100);
|
|
|
|
List<PlantLogModel> LogLevels = new List<PlantLogModel>();
|
|
List<PlantLogModel> LogPressures = new List<PlantLogModel>();
|
|
List<OrderModel> LogOrders = new List<OrderModel>();
|
|
|
|
DateTime adesso = DateTime.Now;
|
|
int lastLevel = simLevel;
|
|
int lastOrder = 0;
|
|
int anticipo = 0;
|
|
double lastPress = simPress;
|
|
double lastPressH = simPressH;
|
|
double lastPressL = simPressL;
|
|
// simulo numDays gg...
|
|
for (int i = numDays * 24 * (60 / stepMin); i > 0; i--)
|
|
{
|
|
anticipo = i * stepMin;
|
|
lastLevel = lastLevel - rnd.Next(0, maxHourRate / (60 / stepMin));
|
|
// se inferiore a soglia 1 --> ordine
|
|
if (lastLevel + lastOrder < soglia01)
|
|
{
|
|
lastOrder = rnd.Next((int)currPlant.LevelMax - soglia01, (int)currPlant.LevelMax - soglia02);
|
|
LogOrders.Add(new OrderModel() { DtOrder = adesso.AddMinutes(-anticipo), OrderQty = lastOrder, PlantId = plant.PlantId, OrderCode = $"ORD{i:000000}", OrderDesc = "SIM Order", SupplierId = 1, TransporterId = 1 });
|
|
}
|
|
|
|
// se inferiore a soglia 2 --> refill
|
|
if (lastLevel < soglia02)
|
|
{
|
|
lastLevel += lastOrder;
|
|
lastOrder = 0;
|
|
}
|
|
LogLevels.Add(new PlantLogModel() { DtEvent = adesso.AddMinutes(-anticipo), FluxType = "Level", PlantId = plant.PlantId, ValNumber = lastLevel });
|
|
|
|
// pressioni!
|
|
lastPress = lastPress - (double)rnd.Next(-30, 25) / 10;
|
|
lastPressH = lastPressH - (double)rnd.Next(-25, 20) / 10;
|
|
lastPressL = lastPressL - (double)rnd.Next(-25, 20) / 10;
|
|
LogPressures.Add(new PlantLogModel() { DtEvent = adesso.AddMinutes(-anticipo), FluxType = "MainPress", PlantId = plant.PlantId, ValNumber = lastPress });
|
|
LogPressures.Add(new PlantLogModel() { DtEvent = adesso.AddMinutes(-anticipo), FluxType = "PressBH", PlantId = plant.PlantId, ValNumber = lastPressH });
|
|
LogPressures.Add(new PlantLogModel() { DtEvent = adesso.AddMinutes(-anticipo), FluxType = "PressBL", PlantId = plant.PlantId, ValNumber = lastPressL });
|
|
}
|
|
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetPlantLog
|
|
.AddRange(LogLevels);
|
|
|
|
dbCtx
|
|
.DbSetPlantLog
|
|
.AddRange(LogPressures);
|
|
|
|
// salvo sul DB!
|
|
dbCtx.SaveChanges();
|
|
Log.Info($"Effettuato inserimento {LogLevels.Count} record PlantLog");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in salvataggio PlantLog{Environment.NewLine}{exc}");
|
|
}
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetOrders
|
|
.AddRange(LogOrders);
|
|
|
|
// salvo sul DB!
|
|
dbCtx.SaveChanges();
|
|
Log.Info($"Effettuato inserimento {LogOrders.Count} record Orders");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in salvataggio Orders{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
#region Public Methods
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database context
|
|
dbCtx.Dispose();
|
|
}
|
|
|
|
public List<ConfigModel> GetConfig()
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetConfig
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<ItemModel> GetItems()
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetItems
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<OrderModel> GetOrdersFilt(int PlantId, int SupplierId, int TransporterId, DateTime DtStart, DateTime DtEnd)
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetOrders
|
|
.Where(x => (x.PlantId == PlantId || PlantId == 0) && (x.SupplierId == SupplierId || SupplierId == 0) && (x.TransporterId == TransporterId || TransporterId == 0) && (x.DtOrder >= DtStart && x.DtOrder <= DtEnd))
|
|
.Include(p => p.Plant)
|
|
.Include(s => s.Supplier)
|
|
.Include(t => t.Transporter)
|
|
.OrderByDescending(x => x.DtOrder)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public PlantDetailModel GetPlant(int PlantId)
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetPlant
|
|
.Where(x => x.PlantId == PlantId)
|
|
.FirstOrDefault();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco log registrati x plant
|
|
/// </summary>
|
|
/// <param name="PlantId">se 0 = tutto</param>
|
|
/// <param name="DtMaxDate">consigliato arrotondamento al minuto o multiplo</param>
|
|
/// <param name="numRec">num rec max da recuperare</param>
|
|
/// <returns></returns>
|
|
public List<PlantLogModel> GetPlantLog(int PlantId, DateTime DtMaxDate, int numRec)
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetPlantLog
|
|
.Where(x => (x.PlantId == PlantId || PlantId == 0) && x.DtEvent <= DtMaxDate)
|
|
.OrderByDescending(x => x.DtEvent)
|
|
.Take(numRec)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<PlantDetailModel> GetPlants()
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetPlant
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<PlantDTO> GetPlantsDTO()
|
|
{
|
|
var plantList = dbCtx
|
|
.DbSetPlant
|
|
.ToList();
|
|
|
|
var dbResult = plantList
|
|
.Select(x => PlantDTO(x.PlantId))
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce ultimi eventi rebootlog
|
|
/// </summary>
|
|
/// <param name="maxNum">num eventi, se 0 = tutti</param>
|
|
/// <returns></returns>
|
|
public List<RebootLogModel> GetRebootLog(int maxNum = 100)
|
|
{
|
|
if (maxNum == 0)
|
|
{
|
|
maxNum = dbCtx.DbRebootLog.Count();
|
|
}
|
|
var dbResult = dbCtx
|
|
.DbRebootLog
|
|
.OrderByDescending(x => x.DtEvent)
|
|
.Take(maxNum)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<SupplierModel> GetSuppliers()
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetSupplier
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<TransporterModel> GetTransporters()
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetTransporter
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<UserModel> GetUsersFilt(UserLevel UsrLvl, int PlantId, int SupplierId, int TransporterId)
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetUser
|
|
.Where(x => (x.Livello == UsrLvl || UsrLvl == UserLevel.ND) && (x.MaskPlantId == PlantId || PlantId == 0) && (x.MaskSupplierId == SupplierId || SupplierId == 0) && (x.MaskTranspId == TransporterId || TransporterId == 0))
|
|
.OrderBy(x => x.Livello)
|
|
.ThenBy(x => x.UserName)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public List<WeekPlanModel> GetWeekPlan()
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetPlantSupplWeekPlan
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
public bool HasPlantLog()
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
var numRecord = dbCtx
|
|
.DbSetPlantLog
|
|
.Count();
|
|
answ = numRecord > 0;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un Ordine
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool OrderUpdate(OrderModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetOrders
|
|
.Where(x => x.OrderId == updItem.OrderId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetOrders
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero info PLANT modalità DTO
|
|
/// </summary>
|
|
/// <param name="PlantId"></param>
|
|
/// <returns></returns>
|
|
public PlantDTO PlantDTO(int PlantId)
|
|
{
|
|
var currPlant = GetPlant(PlantId);
|
|
|
|
List<TSData> LevelTS = new List<TSData>();
|
|
Dictionary<string, double> PressAct = new Dictionary<string, double>();
|
|
Dictionary<string, List<TSData>> PressTS = new Dictionary<string, List<TSData>>();
|
|
List<TSData> PressMainTS = new List<TSData>();
|
|
List<TSData> PressBHTS = new List<TSData>();
|
|
List<TSData> PressBLTS = new List<TSData>();
|
|
List<TSData> OrderTS = new List<TSData>();
|
|
// recupero dal DB
|
|
var rawLevelData = dbCtx
|
|
.DbSetPlantLog
|
|
.Where(x => x.FluxType == "Level" && x.PlantId == PlantId)
|
|
.OrderBy(x => x.DtEvent)
|
|
.ToList();
|
|
|
|
var rawMainPressData = dbCtx
|
|
.DbSetPlantLog
|
|
.Where(x => x.FluxType == "MainPress" && x.PlantId == PlantId)
|
|
.OrderBy(x => x.DtEvent)
|
|
.ToList();
|
|
|
|
var rawBHPressData = dbCtx
|
|
.DbSetPlantLog
|
|
.Where(x => x.FluxType == "PressBH" && x.PlantId == PlantId)
|
|
.OrderBy(x => x.DtEvent)
|
|
.ToList();
|
|
|
|
var rawBLPressData = dbCtx
|
|
.DbSetPlantLog
|
|
.Where(x => x.FluxType == "PressBL" && x.PlantId == PlantId)
|
|
.OrderBy(x => x.DtEvent)
|
|
.ToList();
|
|
|
|
var rawOrderData = dbCtx
|
|
.DbSetOrders
|
|
.Where(x => x.PlantId == PlantId)
|
|
.OrderBy(x => x.DtOrder)
|
|
.ToList();
|
|
|
|
LevelTS = rawLevelData
|
|
.Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();
|
|
|
|
OrderTS = rawOrderData
|
|
.Select(x => new TSData() { DtEvent = x.DtOrder, ValDouble = x.OrderQty }).ToList();
|
|
|
|
PressMainTS = rawMainPressData
|
|
.Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();
|
|
|
|
PressBHTS = rawBHPressData
|
|
.Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();
|
|
|
|
PressBLTS = rawBLPressData
|
|
.Select(x => new TSData() { DtEvent = x.DtEvent, ValDouble = x.ValNumber }).ToList();
|
|
|
|
PressTS.Add("Main", PressMainTS);
|
|
PressTS.Add("BH", PressBHTS);
|
|
PressTS.Add("BL", PressBLTS);
|
|
|
|
PressAct.Add("Main", PressMainTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble);
|
|
PressAct.Add("BH", PressBHTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble);
|
|
PressAct.Add("BL", PressBLTS.OrderByDescending(x => x.DtEvent).Take(1).FirstOrDefault().ValDouble);
|
|
|
|
PlantDTO answ = new PlantDTO()
|
|
{
|
|
PlantId = PlantId,
|
|
PlantCode = currPlant.PlantCode,
|
|
PlantDesc = currPlant.PlantDesc,
|
|
LevelAct = currPlant.LevelAct,
|
|
LevelMax = currPlant.LevelMax,
|
|
PressAct = PressAct,
|
|
LevelTS = LevelTS,
|
|
PressTS = PressTS,
|
|
OrderTS = OrderTS
|
|
};
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserimento di un novo record x plant log
|
|
/// </summary>
|
|
/// <param name="PlantLogModel">Record da inserire (senza ID...)</param>
|
|
/// <returns></returns>
|
|
public bool PlantLogInsertNew(List<PlantLogModel> newItems)
|
|
{
|
|
bool fatto = false;
|
|
|
|
//List<PlantLogModel> newList = new List<PlantLogModel>();
|
|
|
|
//foreach (var item in newItems)
|
|
//{
|
|
// newList.Add(new PlantLogModel()
|
|
// {
|
|
// DtEvent = item.DtEvent,
|
|
// FluxType = item.FluxType,
|
|
// PlantId = item.PlantId,
|
|
// ValNumber = item.ValNumber,
|
|
// ValString = item.ValString
|
|
// });
|
|
//}
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetPlantLog
|
|
.AddRange(newItems);
|
|
//.AddRange(newList);
|
|
|
|
dbCtx.SaveChanges();
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error(exc, $"Eccezione durante PlantLogInsertNew per {newItems.Count} rec");
|
|
}
|
|
|
|
return fatto;
|
|
}
|
|
|
|
public bool RecordRebootLog(RebootLogModel newItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbRebootLog
|
|
.Add(newItem);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rigenera intero DB se riceve ID di un plant SIM...
|
|
/// </summary>
|
|
/// <param name="PlantId"></param>
|
|
public bool RegenDB(int PlantId, int numDays, int stepMin, int maxHourRate)
|
|
{
|
|
bool answ = false;
|
|
var currPlant = GetPlant(PlantId);
|
|
if (currPlant.PlantCode.StartsWith("PIZ"))
|
|
{
|
|
Log.Info("Inizio RegenDB");
|
|
|
|
DbAdmin.resetPlantLogTable();
|
|
|
|
ResetController();
|
|
|
|
CreateSimData(numDays, stepMin, maxHourRate);
|
|
Log.Info("Dati SIM generati");
|
|
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public void ResetController()
|
|
{
|
|
dbCtx = new GWMSContext(_configuration);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Annulla modifiche su una specifica entity (cancel update)
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
public bool rollBackEntity(object item)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
if (dbCtx.Entry(item).State == EntityState.Deleted || dbCtx.Entry(item).State == EntityState.Modified)
|
|
{
|
|
dbCtx.Entry(item).Reload();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un User
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool UserUpdate(UserModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetUser
|
|
.Where(x => x.UserId == updItem.UserId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetUser
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina un item WeekPlan
|
|
/// </summary>
|
|
/// <param name="selRecord"></param>
|
|
/// <returns></returns>
|
|
public bool WeekPlanDelete(WeekPlanModel selRecord)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var item2del = dbCtx
|
|
.DbSetPlantSupplWeekPlan
|
|
.Where(x => x.WeekPlanId == selRecord.WeekPlanId)
|
|
.FirstOrDefault();
|
|
dbCtx.DbSetPlantSupplWeekPlan.Remove(item2del);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item WeekPlan
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool WeekPlanUpdate(WeekPlanModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetPlantSupplWeekPlan
|
|
.Where(x => x.WeekPlanId == updItem.WeekPlanId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetPlantSupplWeekPlan
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
} |