mapo-mono/MP.MONO.DECODER/ParamsManager.cs

using MP.MONO.Core;
using MP.MONO.Core.DTO;
using MP.MONO.Data.DbModels;
using NLog;
using NLua;

namespace MP.MONO.DECODER
{
    public class ParamsManager
    {
        #region Public Fields

        public static string alarmStatus = "";

        public static bool valueChanged = false;

        #endregion Public Fields

        #region Public Constructors

        public ParamsManager()
        {
            // preparo variabile x avvisare script che il modo è da NLua
            state["callMode"] = "NLua";
            state["vcFunct"] = "AVG";

            // carico il file
            luaPath = Path.Combine(Directory.GetCurrentDirectory(), "lua", "ParamsDecoder.lua");
            state.DoFile(luaPath);

            Log.Info("ParamsManager OK");
            Console.WriteLine("ParamsManager OK");
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Funzione chiamata LUA x calcolo degli eventuali parametri con periodi "scaduti"
        /// </summary>
        /// <param name="paramsList"></param>
        /// <param name="redisParamConf"></param>
        /// <returns></returns>
        public List<DataLogModel> processData(Dictionary<string, double> paramsList, List<DisplayDataDTO> redisParamConf)
        {
            List<DataLogModel> answ = new List<DataLogModel>();
            DateTime adesso = DateTime.Now;

            // vado ad "accumulare i dati" a quelli presenti...
            foreach (var item in paramsList)
            {
                var currParam = redisParamConf.FirstOrDefault(x => x.Title == item.Key);
                // cerco nelle variabili accomulatori...
                if (!ParamsAccumulator.ContainsKey(item.Key))
                {
                    if (currParam != null)
                    {
                        var dataList = new List<double>();
                        dataList.Add(item.Value);
                        VCData newSet = new VCData()
                        {
                            dataArray = dataList,
                            DTStart = adesso,
                            Funzione = currParam.VcFunc,
                            Period = currParam.SamplePeriod
                        };
                        // se non ci fosse creo
                        ParamsAccumulator.Add(item.Key, newSet);
                    }
                }
                else
                {
                    // altrimenti aggiorno
                    ParamsAccumulator[item.Key].dataArray.Add(item.Value);
                }

                // effettuo verifiche scadenza
                bool calcOk = false;
                double calcVal = 0;
                if (ParamsAccumulator.ContainsKey(item.Key))
                {
                    if (ParamsAccumulator[item.Key].isElapsed)
                    {
                        string funcMode = $"{ParamsAccumulator[item.Key].Funzione}";
                        // se scaduto --> mando a LUA x calcolo
                        state["valList"] = ParamsAccumulator[item.Key].dataArray;
                        state["numRec"] = ParamsAccumulator[item.Key].dataArray.Count;
                        state["vcFunct"] = funcMode;

                        // effettuo calcolo
                        state.DoString("doProcess()");

                        // recupero valore calcolato
                        bool.TryParse(state.GetString("calcOk"), out calcOk);
                        if (calcOk)
                        {
                            try
                            {
                                var stringVal = state.GetString("calcVal");
                                if (!string.IsNullOrEmpty(stringVal))
                                {
                                    calcVal = state.GetNumber("calcVal");
                                    Log.Trace($"calcVal: {calcVal}");
                                }
                            }
                            catch (Exception exc)
                            {
                                Log.Error($"exception during processData for {item.Key}{Environment.NewLine}{exc}");
                            }
                        }

                        // aggiungo alla lista finale...
                        var dbRecord = new DataLogModel()
                        {
                            DtRif = adesso,
                            FluxType = item.Key,
                            MachineId = 1,
                            DataType = Enums.DataLogType.Parameter,
                            ValNum = calcVal,
                            ValStr = $"{calcVal:N3}"
                        };
                        answ.Add(dbRecord);

                        // elimino dai valori accumulati...
                        ParamsAccumulator.Remove(item.Key);
                    }
                }
            }

            return answ;
        }

        #endregion Public Methods

        #region Protected Fields

        protected static Logger Log = LogManager.GetCurrentClassLogger();

        protected static string luaPath = "";

        protected static Lua state = new Lua();

        protected List<string> AlarmList = new List<string>();

        #endregion Protected Fields

        #region Private Fields

        /// <summary>
        /// Dizionario dei valori accumulati sulle variabili
        /// </summary>
        private Dictionary<string, VCData> ParamsAccumulator = new Dictionary<string, VCData>();

        #endregion Private Fields
    }
}