webdoorcreator/WebDoorCreator.UI/Components/Hardware/HwSingleInstance.razor.cs

using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using Newtonsoft.Json;
using WebDoorCreator.Data.DbModels;
using WebDoorCreator.Data.Services;
using WebDoorCreator.UI.Data;

namespace WebDoorCreator.UI.Components.Hardware
{
    public partial class HwSingleInstance
    {
        #region Public Properties

        [Parameter]
        public DoorOpModel DoorOpInst { get; set; } = null!;

        [Parameter]
        public EventCallback<bool> E_act2Rel { get; set; }

        [Parameter]
        public EventCallback<DoorOpModel> E_recordUpdate { get; set; }
        [Parameter]
        public string HwCode { get; set; } = "";

        [Parameter]
        public int instanceN { get; set; } = 0;

        [Parameter]
        public string Lingua { get; set; } = "EN";

        [CascadingParameter]
        public string userId { get; set; } = "";

        #endregion Public Properties



        #region Protected Properties

        protected Dictionary<string, string> _currVal { get; set; } = new Dictionary<string, string>();

        /// <summary>
        /// Array dati
        /// </summary>
        protected Dictionary<string, string> currVal
        {
            get => _currVal;
            set
            {
                if (value != null)
                {
                    //if (int.TryParse(value["Size"], out int result))
                    _currVal = value;
                }
            }
        }

        protected string folderName
        {
            get => currVal != null ? tryGetCurrVal("Folder") : "";
            set
            {
                if (currVal["Folder"] != value)
                {
                    currVal["Folder"] = value;
                    var pUpd = Task.Run(async () =>
                    {
                        templateName = "";
                        await SetSelectedData();
                    });
                }
            }
        }

        protected Dictionary<string, List<string>> graphicParams { get; set; } = null!;

        protected bool isLoading { get; set; } = false;

        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

        protected List<ListValuesModel>? listValuesFiles { get; set; } = null!;
        protected List<ListValuesModel>? listValuesHW { get; set; } = null!;

        protected List<ListValuesModel>? listValuesFname { get; set; } = null!;

        [Inject]
        protected QueueDataService QDataServ { get; set; } = null!;

        protected string templateName
        {
            get
            {
                string answ = "";
                if (currVal != null)
                {
                    if (currVal[currTempOrSh] != null)
                    {
                        answ = tryGetCurrVal(currTempOrSh);
                    }
                }
                return answ;
            }
            set
            {
                if (currVal[currTempOrSh] != null)
                {
                    if (currVal[currTempOrSh] != value)
                    {
                        currVal[currTempOrSh] = value;
                        DoorOpInst.userConfirm = "";
                        DoorOpInst.DtConfirm = null;
                        if (!string.IsNullOrEmpty(value))
                        {
                            var pUpd = Task.Run(async () =>
                            {
                                // aggiorno direttamente i graphics parameters...
                                var newData = await WDCService.DoorOpGetUpdatedVals(DoorOpInst.ObjectId, currVal, graphicParams, currTempOrSh);
                                currVal = newData.Item1;
                                graphicParams = newData.Item2;
                                await doSave();
                                await SetSelectedData();
                                await E_recordUpdate.InvokeAsync(DoorOpInst);
                            });
                        }
                    }
                }
            }
        }

        [Inject]
        protected WebDoorCreatorService WDCService { get; set; } = null!;

        [Inject]
        protected WDCVocabularyService WDVService { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        protected List<string> comboSet(string pKey)
        {
            List<string> answ = new List<string>();
            if (graphicParams.ContainsKey(pKey))
            {
                answ = graphicParams[pKey].ToList();
            }
            return answ;
        }

        protected async Task doCancel()
        {
            await FullReloadData();
            await InvokeAsync(StateHasChanged);
        }

        protected async Task doClone()
        {
            var doorOpToAdd = DoorOpInst.ObjClone(userId, 0);

            List<DoorOpModel> doorOpAddList = new List<DoorOpModel>() { doorOpToAdd };
            // salvo!
            var done = await WDCService.DoorOpInsert(DoorOpInst.DoorId, doorOpAddList);
            await E_act2Rel.InvokeAsync(done);
            await FullReloadData();
        }

        protected async Task doDeleteInst()
        {
            var delConf = await JSRuntime.InvokeAsync<bool>("confirm", "Delete PERMANENTLY the current record?");

            if (delConf)
            {
                var done = await WDCService.DoorOpDelete(DoorOpInst);
                await E_act2Rel.InvokeAsync(done);
                await FullReloadData();
            }
        }

        protected async Task doSave()
        {
            // salvo i NUOVI valori...
            DoorOpInst.CurrVals = currVal;
            DoorOpInst.GraphicParams = graphicParams;
            // salvo!
            var doorOps2Save = new List<DoorOpModel>() { DoorOpInst };
            await WDCService.DoorOpUpdate(doorOps2Save);
            // invio msg dato "salvabile"
            // rileggo
            await FullReloadData();
        }

        protected bool isChangedVal()
        {
            bool answ = !DoorOpInst.JsoncActValEquals(currVal);
            if (answ)
            {
                DoorOpInst.JsoncActVal = JsonConvert.SerializeObject(currVal);
                Task.Run(async () =>
                {
                    await E_recordUpdate.InvokeAsync(DoorOpInst);
                });
            }
            return answ;
        }

        protected bool isCombo(string pKey)
        {
            bool answ = false;
            if (graphicParams.ContainsKey(pKey))
            {
                answ = graphicParams[pKey].Count > 1;
            }
            return answ;
        }

        protected override async Task OnParametersSetAsync()
        {
            await FullReloadData();
        }

        protected string translate(string lemma)
        {
            string answ = "";

            answ = WDVService.Traduci(Lingua, lemma);

            return answ;
        }

        protected string tryGetCurrVal(string key)
        {
            string answ = "";
            if (currVal.ContainsKey(key))
            {
                answ = currVal[key];
            }
            return answ;
        }

        private string pathFinder(int id)
        {
            string answ = $"HwPdfConfirm?doorOpId={id}&doorId={DoorOpInst.DoorId}&objectId={DoorOpInst.ObjectId}";
            return answ;
        }

        #endregion Protected Methods

        #region Private Methods

        protected string currTempOrSh { get; set; } = "";

        private async Task FullReloadData()
        {
            currVal = DoorOpInst.CurrVals;
            graphicParams = DoorOpInst.GraphicParams;
            await SetSelectedData();
        }
        private async Task SetSelectedData()
        {
            isLoading = true;
            await Task.Delay(1);
            // fix folder
            listValuesFiles = null;
            listValuesHW = null;
            listValuesHW = await WDCService.ListValuesGetAll(HwCode, "Hardware");

            var tempListVal = await WDCService.ListValuesGetAll(HwCode, "Folder");
            if (tempListVal != null)
            {
                listValuesFname = tempListVal;
            }
            if (string.IsNullOrEmpty(folderName))
            {
                if (listValuesFname != null)
                {
                    folderName = listValuesFname.FirstOrDefault()?.Label!;
                }
            }

            // fix template
            var tempListFilesTempl = await WDCService.ListValuesGetAll(HwCode, "template");

            var tempListFilesSh = await WDCService.ListValuesGetAll(HwCode, "shape");

            if (tempListFilesTempl!.Count != 0)
            {
                listValuesFiles = tempListFilesTempl.Where(x => x.Value.Contains(folderName)).ToList();
            }
            else if (tempListFilesSh!.Count != 0)
            {
                listValuesFiles = tempListFilesSh!.Where(x => x.Value.Contains(folderName)).ToList();
            }
            try
            {
                if (listValuesFiles != null && listValuesFiles.Count > 0)
                {
                    currTempOrSh = listValuesFiles.FirstOrDefault()?.FieldName!;
                    if (string.IsNullOrEmpty(templateName))
                    {
                        templateName = listValuesFiles.FirstOrDefault()?.Label!;
                    }
                }
            }
            catch (Exception ex)
            { }
            isLoading = false;
            await InvokeAsync(StateHasChanged);
        }


        protected string getTrad(string objId)
        {
            string answ = "";

            if (listValuesHW != null)
            {
                var currHw2Trad = listValuesHW.Where(x => x.TableName == objId).FirstOrDefault();
                if(currHw2Trad != null)
                {
                    answ = translate(currHw2Trad.Label);
                }
            }

            return answ;
        }

        #endregion Private Methods
    }
}