protected async override Task OnParametersSetAsync()
        {
            await base.OnParametersSetAsync();

            if (_dto.ConsultaId == Guid.Empty)
            {
                _dto.ConsultaId = ConsultaId;
            }

            _consulta = await ConsultasServico.GetAsync(ConsultaId);
        }
        private async Task DesmarcarConsultaAsync()
        {
            if (!Guid.TryParse(_consultaEvento.Id, out Guid consultaId))
            {
                return;
            }

            var httpResponse = await ConsultasServico.DeleteAsync(consultaId);

            if (httpResponse.IsSuccessStatusCode)
            {
                ToastService.ShowSuccess($"Consulta de código {_consultaEvento.Codigo}, foi desmarcada!");
                await CalendarRenderAsync(DateTime.Today, DateTime.Today.AddYears(1));
            }
        }
        protected async override Task OnParametersSetAsync()
        {
            await base.OnParametersSetAsync();

            if (_dto.ConsultaId == Guid.Empty)
            {
                _dto.ConsultaId = ConsultaId;
            }

            if (_dto?.Id != Guid.Empty)
            {
                _tipoDeExameId = _dto.TipoDeExame.Id.ToString();
            }

            consulta = await ConsultasServico.GetAsync(ConsultaId);
        }
        private async Task BuscarAsync()
        {
            if (string.IsNullOrEmpty(_busca))
            {
                return;
            }

            var consulta = await ConsultasServico.GetPorCodigoAsync(_busca);

            if (consulta == null)
            {
                ToastService.ShowInfo($"Nenhuma consulta encontrada com o código {_busca}");
                return;
            }

            await CalendarRenderAsync(consulta.Data, consulta.Data, _busca, "listWeek", consulta.Data);
        }
        private async Task CalendarRenderAsync(DateTime dataInicio, DateTime dataFim, string busca = "", string viewRender = null, DateTime?gotoDate = null)
        {
            _carregando = true;
            StateHasChanged();

            var consultas = await ConsultasServico.GetTudoComFiltrosAsync(dataInicio, dataFim, busca, "Agendada|AguardandoRetorno|Reagendada");

            var datas = await MedicosServico.GetHorariosDeTrabalhoAtivosIntervaloDeDataAsync((_medicoLocalStorage?.Id).GetValueOrDefault(), dataInicio, dataFim);

            var fullCalendarEvent = consultas.Select(_ => new FullCalendarEvent
            {
                Id            = _.Id.ToString(),
                Title         = $"Código: {_.Codigo} - {_.Especialidade.Nome}\nPaciente: {_.Paciente.Nome}",
                Start         = _.Data,
                ExtendedProps = new
                {
                    ConsultaCodigo    = _.Codigo,
                    PacienteNome      = _.Paciente.Nome,
                    EspecialidadeId   = _.Especialidade.Id,
                    EspecialidadeNome = _.Especialidade.Nome,
                    MedicoId          = _.Medico.Id,
                    MedicoNome        = $"{_.Medico.Nome} - CRM {_.Medico.CRM}",
                    StatusId          = _.StatusConsulta.Id,
                    StatusNome        = _.StatusConsulta.Nome,
                },
                BackgroundColor = ObterEventoCor(_.StatusConsultaId).Item1,
                TextColor       = ObterEventoCor(_.StatusConsultaId).Item2,
            });

            _carregando = false;
            StateHasChanged();

            var dotNetReference = DotNetObjectReference.Create(this);

            await JSRuntime.InvokeVoidAsync(
                "fullCalendarJsInterop.calendarRender",
                fullCalendarEvent,
                dotNetReference,
                datas?.Select(_ => new { Data = _.Key, TemHorario = _.Value }),
                viewRender,
                gotoDate);
        }
        protected async override Task <bool> Salvar(EditContext editContext)
        {
            if (string.IsNullOrEmpty(_tipoDeExameId))
            {
                return(false);
            }

            _dto.StatusExame.Id = StatusExameConst.Pendente;
            _dto.TipoDeExame.Id = Guid.Parse(_tipoDeExameId);

            var result = await base.Salvar(editContext);

            if (result)
            {
                await JSRuntime.PrintContentAsync("exame-observacao");

                await ConsultasServico.PutAlterarStatusAsync(_dto.ConsultaId, StatusConsultaConst.AguardandoRetorno);
            }

            return(result);
        }
        private async Task ReAgendarConsultaAsync()
        {
            if (!Guid.TryParse(_consultaEvento.Id, out Guid consultaId))
            {
                return;
            }

            if (_dataDaConsulta == DateTime.MinValue || _dataDaConsulta < DateTime.Now)
            {
                ToastService.ShowError("A data selecionada é inválido!");
                return;
            }

            var consulta = await ConsultasServico.GetAsync(consultaId);

            var dto = new ConsultaDTO
            {
                Data             = _dataDaConsulta.Add(_horarioDaConsulta),
                Observacao       = consulta.Observacao,
                StatusConsultaId = StatusConsultaConst.Reagendada,
                PacienteId       = consulta.PacienteId,
                MedicoId         = consulta.MedicoId,
                EspecialidadeId  = consulta.EspecialidadeId,
            };

            var httpResponse = await ConsultasServico.PutAsync(consultaId, dto);

            if (httpResponse.IsSuccessStatusCode)
            {
                ToastService.ShowSuccess($"Consulta de código {_consultaEvento.Codigo}, foi reagendada!");
                await CalendarRenderAsync(DateTime.Today, DateTime.Today.AddYears(1));
            }
            else
            {
                ToastService.ShowError($"Falha ao tentar reagendar a consulta de código {_consultaEvento.Codigo}!");
            }
        }