gpw_next/GPW.CORE6.Smart/Components/BottoniEntrEsc.razor.cs

using GPW.CORE.Data;
using GPW.CORE.Data.DbModels;
using GPW.CORE.Data.DTO;
using GPW.CORE6.Smart.Data;
using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using System.Data;

namespace GPW.CORE6.Smart.Components
{
    public partial class BottoniEntrEsc : IDisposable
    {
        #region Public Properties

        [Parameter]
        public int IdxDipendente { get; set; } = -1;

        public bool isRecording { get; set; } = false;

        [Parameter]
        public bool IsRicTimb { get; set; } = false;

        [Parameter]
        public List<DailyDataDTO>? ListRecords
        {
            get => listRecords;
            set { listRecords = value; }
        }

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            listRecords = null;
            ListRecords = null;
            GC.Collect();
        }

        #endregion Public Methods

        #region Protected Methods

        /// <summary>
        /// Inserimento record timbratura
        /// </summary>
        /// <param name="IsUscita"></param>
        /// <returns></returns>
        protected async Task<bool> DoAdd(bool IsUscita)
        {
            bool done = false;
            // var accessorie / base
            TimbratureModel currRecord = new TimbratureModel();
            string ipv4 = await MService.getDevIpAsync();
            int idxDip = MService.IdxDipendente;

            // verifico se si trattasse di timbratura uscita da attivita' del giorno precedente...
            if (IsUscita)
            {
                // se il giorno precedente NON fosse stato chiuso...
                DateTime ieri = DataRif.Date.AddDays(-1);
                List<TimbratureModel> ListTimbIeri = await CDService.TimbratureDay(ieri, idxDip);
                // cerco ultima, se fosse entrata...
                if (ListTimbIeri != null && ListTimbIeri.Count > 0)
                {
                    var isEntrata = false;
                    var ultima = ListTimbIeri.OrderByDescending(x => x.DataOra).FirstOrDefault();
                    if (ultima != null)
                    {
                        bool.TryParse($"{ultima.Entrata}", out isEntrata);
                        if (isEntrata)
                        {
                            // chiedo verifica
                            bool doSplit = await JSRuntime.InvokeAsync<bool>("confirm", "Sembra tu stia chiudendo un periodo iniziato in un giorno precedente, vuoi suddividere in set di timbrature per ogni giornata?");

                            // aggiungo chiusura alla timbratura di ieri alle 23.59
                            currRecord = new TimbratureModel()
                            {
                                Entrata = false,
                                Approv = false,
                                CodTipoTimb = "Web",
                                DataOra = ieri.AddDays(1).AddSeconds(-1),
                                IdxDipendente = idxDip,
                                Ipv4 = $"{ipv4}"
                            };
                            done = await CDService.TimbratureUpdate(currRecord);

                            if (done)
                            {
                                // aggiungo apertura ad oggi
                                currRecord = new TimbratureModel()
                                {
                                    Entrata = true,
                                    Approv = false,
                                    CodTipoTimb = "Web",
                                    DataOra = ieri.AddDays(1),
                                    IdxDipendente = idxDip,
                                    Ipv4 = $"{ipv4}"
                                };
                                done = await CDService.TimbratureUpdate(currRecord);
                            }
                        }
                    }
                }
            }

            // seleziono data-ora timbratura
            DateTime dtTimb = DateTime.Now;
            bool preApprov = true;
            // effettuo controllo: se IP non fosse interno --> arrotondo 5 minuti!
            if (!ipv4.Contains(LocalNet))
            {
                // arrotondo ingresso/uscita ai 5 minuti secondo sia entrata o uscita...
                dtTimb = Utils.DateRounded(DataRif, 5, IsUscita);
                preApprov = false;
            }
            // altrimenti
            currRecord = new TimbratureModel()
            {
                Entrata = !IsUscita,
                Approv = preApprov,
                CodTipoTimb = "Web",
                DataOra = dtTimb,
                IdxDipendente = idxDip,
                Ipv4 = $"{ipv4}"
            };

            // aggiorno
            done = await CDService.TimbratureUpdate(currRecord);
            await Task.Delay(1);
            await ReloadData();
            return done;
        }

        protected override async Task OnInitializedAsync()
        {
            await ReloadData();
        }

        protected override async Task OnParametersSetAsync()
        {
            await ReloadData();
            await Task.Delay(1);
        }

        #endregion Protected Methods

        #region Private Fields

        private DateTime DataRif = DateTime.Now;
        private string LocalNet = "10.74";
        private string textDtAct = "";

        #endregion Private Fields

        #region Private Properties

        [Inject]
        private CoreSmartDataService CDService { get; set; } = null!;

        [Inject]
        private IHttpContextAccessor httpContextAccessor { get; set; } = null!;

        /// <summary>
        /// Gestione timbrature interne/esterne (DA FARE!!!)
        /// </summary>
        private bool isInternal { get; set; } = false;

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

        /// <summary>
        /// Determina il tipo di chiamata ammessa successiva (entrata/uscita)
        /// </summary>
        private string lastAction
        {
            get => MService.LastAction;
            set => MService.LastAction = value;
        }

        private List<DailyDataDTO>? listRecords { get; set; } = null;

        [Inject]
        private MessageService MService { get; set; } = null!;

        [Inject]
        private NavigationManager NavManager { get; set; } = null!;

        /// <summary>
        /// Determina il tipo di chiamata ammessa successiva (entrata/uscita)
        /// </summary>
        private bool nextIsEntrata
        {
            get => MService.NextIsEntrata;
            set => MService.NextIsEntrata = value;
        }

        /// <summary>
        /// Orario in cui si fa richiesta
        /// </summary>
        private DateTime oraRichiestaTimb
        {
            get => MService.targetDateMancTimb;
        }

        private string toastCss
        {
            get => isRecording ? "show" : "";
        }

        #endregion Private Properties

        #region Private Methods

        private async Task doRichiesta(bool isEntrata)
        {
            TimbratureModel currRecord = new TimbratureModel();
            // recupero ip...
            string ipv4 = await MService.getDevIpAsync();
            if (string.IsNullOrEmpty(ipv4))
            {
                if (httpContextAccessor.HttpContext != null)
                {
                    var remoteIp = $"{httpContextAccessor.HttpContext.Connection?.RemoteIpAddress}";
                    // provo a recuperare ipV4...
                    ipv4 = EgwCoreLib.Razor.Data.IpUtils.getLocalIpv4(remoteIp);
                }
            }
            // arrotondo ingresso/uscita ai 5 minuti secondo sia entrata o uscita...
            var dtTimb = Utils.DateRounded(oraRichiestaTimb, 5, !isEntrata);
            // genero record
            currRecord = new TimbratureModel()
            {
                Entrata = isEntrata,
                Approv = false,
                CodTipoTimb = "NoTim",
                DataOra = dtTimb,
                IdxDipendente = MService.IdxDipendente,
                Ipv4 = $"{ipv4}"
            };

            await CDService.TimbratureInsRichiesta(currRecord);

            NavManager.NavigateTo(NavManager.Uri, true);
        }

        private async Task registraTimbratura(bool isEntrata)
        {
            DateTime adesso = DateTime.Now;
            textDtAct = $"{adesso:dddd dd.MM.yyyy}";
            string lastAct = isEntrata ? "INGRESSO" : "USCITA";
            lastAction = $"Registrato evento {lastAct} alle {adesso:HH:mm}";
            // inidico inizio update
            isRecording = true;
            bool done = await DoAdd(!isEntrata);
            // solo se ha fatto mostro udpate
            if (done)
            {
                nextIsEntrata = !isEntrata;
                MService.ReportTimbratura();
                // chiudo visualizzazione stato update
                await Task.Delay(5000);
            }
            isRecording = false;
        }

        private async Task ReloadData()
        {
            DataRif = DateTime.Now;
            var confNet = await CDService.ConfigGetKey("LocalNet");
            LocalNet = confNet != null ? confNet.valore : "10";
        }

        #endregion Private Methods
    }
}