lux/Lux.API/Services/ExternalMessageProcessor.cs

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

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

        public ExternalMessageProcessor(ImageCacheService imgService)
        {
            _cacheService = imgService;
        }

        #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<ProcessArgsResult>(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, newSvg);
                            }
                        }
                    }
                }
                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 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 richeista 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
    }
}