webwindowconfigurator/Test.UI/Components/Pages/EditJWD.razor.cs

using Egw.Window.Data;
using EgwCoreLib.Lux.Core;
using EgwCoreLib.Lux.Core.RestPayload;
using EgwCoreLib.Lux.Data.Services;
using Microsoft.AspNetCore.Components;
using Newtonsoft.Json;
using NLog;
using System.Diagnostics;
using System.Security.AccessControl;
using WebWindowComplex;
using WebWindowComplex.DTO;

namespace Test.UI.Components.Pages
{
    public partial class EditJWD : IDisposable
    {

        #region Public Fields

        public string InitialJwd = "";

        #endregion Public Fields

        #region Public Properties

        public Template SelTemplate { get; set; } = new Template(0, "---SELECT---", "", "");

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            DLService.CalcDonePipe.EA_NewMessage -= CalcDonePipe_EA_NewMessage;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// Predisposizione valori live SVG/JWD
        /// </summary>
        protected LivePayload CurrData = new LivePayload();

        protected string currJwd = "...";
        protected Dictionary<string, string> m_CurrArgs = new Dictionary<string, string>();
        protected string prevJwd = "";
        /// <summary>
        /// Configurazione elenchi anagrafiche
        /// </summary>
        protected BaseListPayload SetupList = new BaseListPayload();

        #endregion Protected Fields

        #region Protected Properties

        protected List<string> AvailColorMaterialList { get; set; } = new List<string>()
        {
            new string("White"),
            new string("Black"),
            new string("Blu")
        };

        protected List<string> AvailFamilyHardwareList { get; set; } = new List<string>()
        {
            new string("ArTech"),
            new string("ArTechPlana")
        };

        protected List<string> AvailGlassList { get; set; } = new List<string>()
        {
            new string("Vetro BE 2S 4/12/4"),
            new string("Vetro BE 2S 4/16/4"),
            new string("Vetro BE 3S 4/12/4/12/4"),
            new string("Vetro BE 3S 4/16/4/16/4"),
            new string("Vetro BE 2S 4T/12/4T"),
            new string("Vetro BE 2S 4T/16/4T")
        };

        protected List<Hardware> AvailHardwareList { get; set; } = new List<Hardware>();
        protected List<string> AvailMaterialList { get; set; } = new List<string>()
        {
            new string("Pino"),
            new string("Abete")
        };

        protected List<string> AvailProfileList { get; set; } = new List<string>()
        {
            new string("Profilo60"),
            new string("Profilo78"),
            new string("Profilo90")
        };

        protected List<TemplateSelectDTO> AvailTemplateList { get; set; } = new List<TemplateSelectDTO>();
        [Inject]
        protected IConfiguration Config { get; set; } = null!;

        [Inject]
        protected DataLayerServices DLService { get; set; } = null!;

        [Inject]
        protected ImageCacheService ICService { get; set; } = null!;

        protected MarkupString JsonSer
        {
            get => (MarkupString)currJwd.Replace(Environment.NewLine, "<br/>").Replace(" ", "&nbsp;");
        }

        protected string SelColorMaterial { get; set; } = "";
        protected string SelFamilyHardware { get; set; } = "";
        protected string SelGlass { get; set; } = "";
        protected string SelMaterial { get; set; } = "";

        #endregion Protected Properties

        #region Protected Methods

        protected override async Task OnInitializedAsync()
        {
            ConfInit();
            InitialJwd = File.ReadAllText("Data\\AntaDoppia.jwd");
            currJwd = InitialJwd;
            // rileggo altri dati
            await ReloadData();
            // preparo conf oggetti x controllo
            SetupList = new BaseListPayload()
            {
                ColorMaterial = AvailColorMaterialList,
                FamilyHardware = AvailFamilyHardwareList,
                Glass = AvailGlassList,
                //FamilyHardware = new List<string>(),
                //Material = new List<string>(),
                Hardware = AvailHardwareList,
                Material = AvailMaterialList,
                Profile = AvailProfileList,
                TemplateDTO = null
            };
            CurrData = new LivePayload()
            {
                CurrJwd = InitialJwd,
                SvgPreview = currSvg
            };
            DLService.CalcDonePipe.EA_NewMessage += CalcDonePipe_EA_NewMessage;
        }

        #endregion Protected Methods

        #region Private Fields

        private string apiUrl = "";
        private string calcTag = "";
        private string CalcUid = "CurrWindow";
        private string cFileHardware = "Hardware/Setup.json";
        private string cFileTemplate = "Data/Setup.json";
        private TemplateSelectDTO? currSel = null;
        private string currSvg = "";

        private string GenericBasePath = "";
        private string imgBasePath = "";
        private string outClose = "";
        private string outSave = "";
        private string subChannel = "";

        private string windowUid = "CurrWindow";

        #endregion Private Fields

        #region Private Methods

        private async void CalcDonePipe_EA_NewMessage(object? sender, EventArgs e)
        {
            // aggiorno visualizzazione
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly SVG da mostrare
            if (!string.IsNullOrEmpty(currArgs.newMessage))
            {
                if (currArgs.msgUid.Equals($"{subChannel}:{windowUid}"))
                {
                    currSvg = currArgs.newMessage;
                    CurrData.SvgPreview = currArgs.newMessage;
                }
                await InvokeAsync(StateHasChanged);
            }
            await Task.Delay(1);
        }

        /// <summary>
        /// Effettua chiusura oggetto con eventuale save
        /// </summary>
        /// <param name="reqSave"></param>
        private void CloseObj(bool reqSave)
        {
            outClose = !reqSave ? "Richiesto chiusura!" : "";
            outSave = reqSave ? "Richiesto salvataggio!" : "";
        }

        private void ConfInit()
        {
            apiUrl = Config.GetValue<string>("ServerConf:Prog.ApiUrl") ?? "";
            imgBasePath = Config.GetValue<string>("ServerConf:ImageBaseUrl") ?? "";
            GenericBasePath = Config.GetValue<string>("ServerConf:GenericBaseUrl") ?? "";
            calcTag = Config.GetValue<string>("ServerConf:CalcTag") ?? "";
            subChannel = Config.GetValue<string>("ServerConf:SvgChannel") ?? "";
        }

        /// <summary>
        /// Rilettura dati
        /// </summary>
        /// <returns></returns>
        private async Task ReloadData()
        {
            //return base.OnInitializedAsync();
            AvailTemplateList = new List<TemplateSelectDTO>();
            AvailHardwareList = new List<Hardware>();
            // brutale, da rivedere...
            if (string.IsNullOrEmpty(InitialJwd))
            {
                if (File.Exists(cFileTemplate))
                {
                    string rawVal = File.ReadAllText(cFileTemplate);
                    var rawList = JsonConvert.DeserializeObject<List<TemplateSelectDTO>>(rawVal) ?? new List<TemplateSelectDTO>();

                    // calcolo URL immagini... DTO interno da rivedere?
                    foreach (var item in rawList)
                    {
                        item.ImageUrl = ICService.ImageUrl($"{apiUrl}/{imgBasePath}", false, item.SVGFileName);
                        AvailTemplateList.Add(item);
                    }
                }
            }
            if (File.Exists(cFileHardware))
            {
                string rawValHW = File.ReadAllText(cFileHardware);
                var rawListHW = JsonConvert.DeserializeObject<List<Hardware>>(rawValHW) ?? new List<Hardware>();
                foreach (var item in rawListHW)
                {
                    AvailHardwareList.Add(item);
                }
            }
            await Task.Delay(100);
        }

        private async Task SaveJWD(Dictionary<string, string> CurrArgs)
        {
            outClose = "";
            outSave = "";
            m_CurrArgs = CurrArgs;
            // verifico se contiene JWD, lo aggiorno
            if (CurrArgs.ContainsKey("Jwd"))
            {
                currJwd = CurrArgs["Jwd"];
                CurrData.CurrJwd = currJwd;
            }

            // se il SSE variato --> invio
            if (!currJwd.Equals(prevJwd))
            {
                prevJwd = currJwd;
                CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
                calcRequestDTO.EnvType = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;
                calcRequestDTO.DictExec = m_CurrArgs;
                // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
                await ICService.CallRestPost($"{apiUrl}/{GenericBasePath}", $"{calcTag}/{CalcUid}", calcRequestDTO);
            }
        }

        private void SetTemplate(TemplateSelectDTO selTemp)
        {
            string rawVal = "";
            currSel = selTemp;
            // brutale,d a rivedere...
            if (File.Exists(selTemp.JwdFileName))
            {
                rawVal = File.ReadAllText(selTemp.JwdFileName);
            }
            SelTemplate = new Template(selTemp.Index, selTemp.Description, selTemp.SVGFileName, rawVal);
        }

        #endregion Private Methods
    }
}