lux/Lux.API/Services/ExternalMessageProcessor.cs

using EgwCoreLib.Lux.Data.Services;
using EgwCoreLib.Lux.Data;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Diagnostics;
using EgwMultiEngineManager.Data;

namespace Lux.API.Services
{
    public class ExternalMessageProcessor
    {
        #region Public Constructors

        /// <summary>
        /// Init classe message processor con accesso REDIS e DB
        /// </summary>
        /// <param name="imgService"></param>
        /// <param name="dlService"></param>
        public ExternalMessageProcessor(ImageCacheService imgService, DataLayerServices dlService)
        {
            cacheService = imgService;
            dbService = dlService;
        }

        #endregion Public Constructors

        #region Public Methods

        public async Task HandleResultMessageAsync(string channel, string message)
        {
            Log.Info($"Processing message from {channel} | {message.Length}");

            Stopwatch sw = new Stopwatch();
            sw.Start();
            string rawData = $"{message}";
            if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
            {
                try
                {
                    var retData = JsonConvert.DeserializeObject<AnswerDTO>(rawData);
                    if (retData != null)
                    {
                        if (retData.Args != null && retData.Args.Count > 0)
                        {
                            if (retData.Args.ContainsKey("Svg"))
                            {
                                // dovrei leggere dagli args l'IUID dell'SVG ritornato...
                                // salvo SVG
                                string newSvg = retData.Args["Svg"];
                                string UID = retData.Args["UID"];
                                await cacheService.SaveSvgAsync(UID, retData.ExecEnvironment, newSvg);
                            }
                            if (retData.Args.ContainsKey("BOM"))
                            {
                                // salvo BOM ricevuta
                                string newBom = retData.Args["BOM"];
                                string UID = retData.Args["UID"];
                                await cacheService.SaveBomAsync(UID, retData.ExecEnvironment, newBom);
                                await dbService.SaveBomAsync(UID, retData.ExecEnvironment, newBom);
                            }
                            if (retData.Args.ContainsKey("HardwareModelList"))
                            {
                                // salvo HardwareList ricevuta
                                string newHml = retData.Args["HardwareModelList"];
                                string UID = retData.Args["UID"];
                                await cacheService.SaveHmlAsync(UID, retData.ExecEnvironment, newHml);
                                await dbService.SaveHmlAsync(UID, retData.ExecEnvironment, newHml);
                            }
                        }
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in fase decodifica messaggio da REDIS Channel{Environment.NewLine}{exc}");
                }
            }

            sw.Stop();
            Log.Info($"HandleResultMessageAsync | {sw.Elapsed.TotalMilliseconds:N3} ms");
#if false
            // Process message (parse, validate, act)
            var payload = message; // or JSON-deserialize, etc.
            await _redisService.SetAsync("last:result", payload);
#endif
        }

        #endregion Public Methods

        #region Private Fields

        private readonly ImageCacheService cacheService;
        private readonly DataLayerServices dbService;
        private static Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

#if false
        /// <summary>
        /// Restituisce una risposta all'esecuzione
        /// </summary>
        /// <param name="ProcessArgsResult"></param>
        private void ProcessMan_m_AnswerReceived(ProcessArgsResult result)
        {
            // verifico che sia la mia richiesta con id immagine... FARE!!!
            // salvo il risultato...
            if (result.Args != null && result.Args.Count > 0)
            {
                if (result.Args.ContainsKey("Svg"))
                {
                    // salvo SVG
                    string newSvg = result.Args["Svg"];
                    // salvo nel dizionario
                    lastSvg = newSvg;
                    // salvo su redis
                    _imgService.SaveSvg("123456", lastSvg);
                }
            }
        }

        /// <summary>
        /// Salva risultato calcolo da broadcast channel REDIS
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="message"></param>
        private void SaveCalcData(RedisChannel channel, RedisValue message)
        {
            string rawData = $"{message}";
            if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
            {
                // provo a deserializzare
                try
                {
                    var retData = JsonConvert.DeserializeObject<ProcessArgsResult>(rawData);
                    if (retData != null)
                    {
                        // verifico nId di risposta x salvare correttamente
                        ProcessMan_m_AnswerReceived(retData);
                    }
                }
                catch (Exception exc)
                {
                    _logger.LogError($"Errore in fase decodifica messaggio da REDIS Channel{Environment.NewLine}{exc}");
                }
            }
        }
#endif
    }
}