private void Consultar(HttpContext context)
{
Model.Entities.Agenda agenda = new Model.Entities.Agenda();
JavaScriptSerializer serializer = new JavaScriptSerializer();
ReturnJSON <Model.Entities.Agenda> returnJSON = new ReturnJSON <Model.Entities.Agenda>();
String retorno = null;
try
{
String json = new StreamReader(context.Request.InputStream).ReadToEnd();
agenda = (Model.Entities.Agenda)serializer.Deserialize <Model.Entities.Agenda>(json);
agenda = new AgendaRepository().Details(new Model.Entities.Agenda()
{
AgendaID = agenda.AgendaID
});
returnJSON.Entity = agenda;
returnJSON.ReturnCode = Enum.GetName(typeof(ReturnType), ReturnType.SUCCESS);
context.Response.StatusCode = 200;
}
catch (Exception e)
{
Log.Create(e);
Email.Send("Agendamento de congelação - falha na aplicação", e);
returnJSON.Message = "Não foi possível recuperar os registros.";
returnJSON.ReturnCode = Enum.GetName(typeof(ReturnType), ReturnType.ERROR);
context.Response.StatusCode = 500;
}
retorno = serializer.Serialize(returnJSON);
context.Response.ContentType = "text/json";
context.Response.ContentEncoding = Encoding.UTF8;
context.Response.Write(retorno);
}
private void CarregarParaEdicao(Int32 id)
{
try
{
Agenda agenda = new Agenda();
agenda = new AgendaRepository().Details(new Agenda()
{
AgendaID = id
});
this.txtDataAgenda.Text = agenda.DataHoraEvento.Value.ToString("yyyy-MM-dd");
this.txtHoraAgenda.Text = agenda.DataHoraEvento.Value.ToString("HH:mm");
this.txtLocal.Text = agenda.Local;
this.txtNomePaciente.Text = agenda.NomePaciente;
this.txtConvenio.Text = agenda.Convenio;
this.txtProcedimento.Text = agenda.Procedimento;
this.txtNomeMedico.Text = agenda.NomeMedico;
this.ddlMedicoExecucaoAgenda.SelectedValue = agenda.MedicoExecucaoAgenda.MedicoExecucaoAgendaID.Value.ToString();
this.ddlEstadoAgenda.SelectedValue = agenda.EstadoAgenda.EstadoAgendaID.Value.ToString();
this.txtTelefoneContato.Text = agenda.TelefoneContato;
}
catch (Exception e)
{
Log.Create(e);
Email.Send("Agendamento de congelação - falha na aplicação", e);
this.msgDialog.Show
(
"Erro"
, "Não foi possível carregar os registros para edição."
, UserControl.Message.Type.Error
);
}
}
public JsonResult getCreateAgendaData(string prData)
{
DateTime lData;
List <AgendaDTO> lRetorno = new List <AgendaDTO>();
if (DateTime.TryParse(prData, out lData) && empresa != null)
{
//REMOVER***************************************************************************
//lData = new DateTime(2019, 10, 23);
AgendaRepository lAgendaRepository = new AgendaRepository();
lRetorno = lAgendaRepository.getAgendaDTO(lData, empresa.empresaid);
if (lRetorno.Count == 0)
{
CriarAgendaAutomatica lCriarAgendaAutomatica = new CriarAgendaAutomatica(aContextoExecucao);
lCriarAgendaAutomatica.criar(lData);
lRetorno = lCriarAgendaAutomatica.acoAgendaDTO;
}
}
return(new CustomJsonResult(true)
{
Data = lRetorno
});
}
public HomeController()
{
_repocitasdia = new AgendaRepository();
_agenda = new AgendaMuestra();
_intervalo = 10;
_columnas = 1;
}
public List <AgendaDTO> getCreateAgenda(DateTime?prData = null)
{
DateTime lData = prData == null ? DateTime.Now.Date : prData.Value.Date;
//REMOVER***************************************************************************
//lData = new DateTime(2019, 10, 23);
AgendaRepository lAgendaRepository = new AgendaRepository();
List <AgendaDTO> lRetorno = new List <AgendaDTO>();
if (empresa != null)
{
lRetorno = lAgendaRepository.getAgendaDTO(lData, empresa.empresaid);
if (lRetorno.Count == 0)
{
CriarAgendaAutomatica lCriarAgendaAutomatica = new CriarAgendaAutomatica(aContextoExecucao);
lCriarAgendaAutomatica.criar(lData);
lRetorno = lCriarAgendaAutomatica.acoAgendaDTO;
}
foreach (var item in lRetorno)
{
if (item.cliente != null && item.cliente.datanascimento.HasValue)
{
item.cliente.datanascimento = item.cliente.datanascimento.Value.Date;
}
if (item.cliente != null && item.cliente.dataultimoservico.HasValue)
{
item.cliente.dataultimoservico = item.cliente.dataultimoservico.Value.Date;
}
}
}
return(lRetorno);
}
private void CarregarAgendaDoDia(DateTime agendaDoDia)
{
try
{
Agenda agenda = new Agenda();
DateTime horaInicial = new DateTime(agendaDoDia.Year, agendaDoDia.Month, agendaDoDia.Day, 0, 0, 0);
DateTime horaFinal = new DateTime(agendaDoDia.Year, agendaDoDia.Month, agendaDoDia.Day, 23, 59, 59);
List <Agenda> agendas = new AgendaRepository().Retreave(new Agenda(), horaInicial, horaFinal);
agendas = agendas
.Where(a => a.Ativo.Value)
.OrderBy(a => a.DataHoraEvento)
.ToList();
this.btnNovo.Visible = (agendas.Count > 0 ? true : false);
this.gvAgendaDoDia.DataSource = agendas;
this.gvAgendaDoDia.DataBind();
}
catch (Exception e)
{
Log.Create(e);
Email.Send("Agendamento de congelação - falha na aplicação", e);
this.msgDialog
.Show
(
"Erro"
, "Ocorreu uma falha ao carregar a agenda do dia."
, UserControl.Message.Type.Error
);
}
}
public void CarregarAgenda(Agenda agenda)
{
try
{
agenda = new AgendaRepository().Details(agenda);
this.txtDataEvento.Text = agenda.DataHoraEvento.Value.ToString("yyyy-MM-dd");
this.txtHoraEvento.Text = agenda.DataHoraEvento.Value.ToString("HH:mm:ss");
this.txtLocal.Text = agenda.Local;
this.txtNomeMedico.Text = agenda.NomeMedico;
this.txtNomePaciente.Text = agenda.NomePaciente;
this.txtConvenio.Text = agenda.Convenio;
this.txtProcedimento.Text = agenda.Procedimento;
String telefoneMascara =
String.Format(
"({0}) {1}"
, agenda.TelefoneContato.Substring(0, 2)
, agenda.TelefoneContato.Remove(0, 2)
);
this.txtTelefone.Text = telefoneMascara;
this.txtEstadoAgenda.Text = agenda.EstadoAgenda.Estado;
this.CarreagarMedicoExecucaoAgenda(agenda.MedicoExecucaoAgenda);
}
catch (Exception e)
{
Log.Create(e);
Email.Send("Agendamento de congelação - falha na aplicação", e);
this.msgDialog.Show("Erro", "Ocorreu uma falha ao carregar o registro da agenda.", UserControl.Message.Type.Error);
}
}
public AgendaService()
{
_dataContext = new DataContext();
_agendaRepository = new AgendaRepository();
_medicoRepository = new MedicoRepository();
_pacienteRepository = new PacienteRepository();
ResponseService = new ResponseService();
}
public void DeleteRegistroInvalido()
{
AgendaRepository agendaRepository = new AgendaRepository();
Contato contato = new Contato {
Nome = "Nome Teste", Telefone = "41999999999", Email = "*****@*****.**"
};
agendaRepository.Delete(0);
Assert.IsTrue(contato.Equals("Nome Teste"));
}
public void SaveNomeTelefoneVazio()
{
AgendaRepository agendaRepository = new AgendaRepository();
Contato contato = new Contato {
Nome = "", Telefone = "", Email = "*****@*****.**"
};
int idGerado = agendaRepository.Save(contato);
contato.ID = idGerado;
agendaRepository.Delete(idGerado);
Assert.IsTrue(idGerado > 0);
}
private void IniciarProcesso()
{
List <Agenda> agendas = new List <Agenda>();
Int32 notificacaoAntecipacaoHoras = Convert.ToInt32(ConfigurationManager.AppSettings["NOTIFICACAO_ANTECIPACAO_HORAS"]);
agendas = new AgendaRepository().VerificarAgendados(notificacaoAntecipacaoHoras);
if (agendas.Count != 0)
{
this.EnviarEmail(agendas);
}
}
/*FUNCIONES*/
/*************************************************************************************/
public RegistrarAgendaForm(Usuario usua)
{
InitializeComponent();
usuario = usua;
agendaDAO = new AgendaRepository();
agenda = agendaDAO.traerAgendaDelProfesional(usuario);
especialidadesDelProfesional = agendaDAO.traerEspecialidadesDeProfesional(usuario);
cargarElementosDeLaVista();
}
public IHttpActionResult GetConfirmacao([FromUri] int idAgenda)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Confirmações retornada com sucesso", repository.GetConfirmacoes(idAgenda))));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao retornar as confirmações", ex.Message)));
}
}
}
public IHttpActionResult Post([FromBody] AgendaForm model)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Agendamento realizado com sucesso", repository.SalvarAgendamento(model))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao salvar o agendamento", ex.Message)));
}
}
}
public IHttpActionResult Lembrete()
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Lista de lembretes", repository.GetLembretes())));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao retornar a lista de lembretes", ex.Message)));
}
}
}
public IHttpActionResult GetAgendamentosDia([FromUri] DateTime?data = null)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Lista de agendamentos do dia", repository.GetAgendamentosDia(data))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao retornar a lista de agendamentos do dia", ex.Message)));
}
}
}
public IHttpActionResult GetAgendamentoPai([FromUri] int key)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Agendamento retornado com sucesso", repository.GetAgendamentoPai(key))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao retornar o agendamento", ex.Message)));
}
}
}
public IHttpActionResult LiberarHorario([FromBody] int key)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "O(s) horário(s) do doutor foi(ram) liberados", repository.LiberarHorarioAgendaDoutor(key))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao liberar o horário do doutor", ex.Message)));
}
}
}
public IHttpActionResult RegistrarExcecaoAgendaDoutor([FromBody] Doutor_ExcecaoAgenda entity)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "O(s) horário(s) do doutor foi(ram) excluidos", repository.RegistrarExcecaoAgendaDoutor(entity))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao excluir o horário do doutor", ex.Message)));
}
}
}
public IHttpActionResult FinalizarAtendimento([FromBody] int idAgenda)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Atendimento finalizado com sucesso", repository.FinalizarAtendimento(idAgenda))));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao registrar o fim do atendimento", ex.Message)));
}
}
}
public IHttpActionResult RegistrarConfirmacao([FromBody] Agenda_Confirmacao model)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Confirmação registrada com sucesso", repository.RegistrarConfirmacao(model))));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao registrar a confirmação", ex.Message)));
}
}
}
public IHttpActionResult GetRelatorioTotalAgendamentosDiarioDoutor([FromUri] RelatorioTotalAgendamentosDiarioDoutorModel model)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Relatório retornado com sucesso", repository.RelatorioTotalAgendamentosDiarioDoutor(model))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao retornar o relatório", ex.Message)));
}
}
}
public IHttpActionResult RegistrarFalta([FromBody] int idAgenda)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Falta registrada com sucesso", repository.RegistrarFalta(idAgenda))));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao registrar a falta", ex.Message)));
}
}
}
public IHttpActionResult ReagendarAtendimento([FromBody] ReagendarAtendimentoModel model)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Atendimento reagendado com sucesso", repository.ReagendarAtendimento(model))));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao reagendar o atendimento", ex.Message)));
}
}
}
public async Task <IList <AgendaAppointmentDTO> > GetUserAgendaAppointment(User user)
{
var list = _agendaRepository.GetUserAgendaAppointment(user);
return(list.Select(o =>
new AgendaAppointmentDTO
{
ID = o.ID,
Date = o.DateSchedule,
Professional = o.AgendaSchedule.Agenda.Professional.User.PersonalInfo.Name,
AppointmentType = o.AgendaSchedule.Agenda.AppointmentType.Name,
BeginTime = AgendaRepository.ConvertMinutesToDateTime(o.DateSchedule, o.BeginTime).ToString("HH:mm"),
EndTime = AgendaRepository.ConvertMinutesToDateTime(o.DateSchedule, o.EndTime).ToString("HH:mm"),
Status = o.Status.GetHashCode()
}).ToList());
}
public async Task <IActionResult> GetUserAgendaAppointment()
{
var agendaRepository = new AgendaRepository(_context);
var agendaService = new AgendaService(agendaRepository);
var userRepository = new UserRepository(_context);
var authenticadedUser = ((ClaimsIdentity)User.Identity).Claims.FirstOrDefault()?.Value;
var user = await userRepository.GetUserFromEmailOrOauthID(authenticadedUser);
if (user == null)
{
return(NotFound("Usuário não encontrado"));
}
return(Json(agendaService.GetUserAgendaAppointment(user).Result));
}
public IHttpActionResult GetAgendamentosPorperiodo(
[FromUri] int idDoutor,
[FromUri] DateTime dataInicio,
[FromUri] DateTime dataFim)
{
using (var repository = new AgendaRepository())
{
try
{
return(Ok(CreateResponse(true, "Lista de agendamentos por período do doutor na data informada", repository.RetornarPorPeriodo(idDoutor, dataInicio, dataFim))));
}
catch (System.Exception ex)
{
return(Content(HttpStatusCode.BadRequest, CreateResponse(false, "Erro ao retornar a lista de agendamentos por período do doutor na data informada", ex.Message)));
}
}
}
public async Task <IActionResult> GetProfessionalSchedule([FromQuery] string jsdate)
{
var agendaRepository = new AgendaRepository(_context);
var agendaService = new AgendaService(agendaRepository);
var userRepository = new UserRepository(_context);
var date = DateTime.Parse(jsdate, CultureInfo.InvariantCulture);
var authenticadedUser = ((ClaimsIdentity)User.Identity).Claims.FirstOrDefault()?.Value;
var user = await userRepository.GetUserFromEmailOrOauthID(authenticadedUser);
if (user == null)
{
return(NotFound("Usuário não encontrado"));
}
return(Json(agendaService.GetProfessionalUserSchedules(user, date).Result));
}
public void Update()
{
AgendaRepository agendaRepository = new AgendaRepository();
Contato contato = new Contato {
Nome = "Nome Teste", Telefone = "41999999999", Email = "*****@*****.**"
};
int idGerado = agendaRepository.Save(contato);
contato.ID = idGerado;
contato.Nome += " alterado";
agendaRepository.Update(contato);
Contato contatoGerado = agendaRepository.GetContatoById(idGerado);
agendaRepository.Delete(idGerado);
Assert.IsTrue(contatoGerado.Nome.Equals("Nome Teste alterado"));
}
private void CarregarAgenda(Int32 id)
{
try
{
Agenda agenda = new Agenda();
agenda = new AgendaRepository().Details(new Agenda()
{
AgendaID = id
});
this.txtDataEvento.Text = agenda.DataHoraEvento.Value.ToString("yyyy-MM-dd");
this.txtHoraEvento.Text = agenda.DataHoraEvento.Value.ToString("HH:mm");
this.txtLocal.Text = agenda.Local;
this.txtNomePaciente.Text = agenda.NomePaciente;
this.txtConvenio.Text = agenda.Convenio;
this.txtProcedimento.Text = agenda.Procedimento;
this.txtNomeMedico.Text = agenda.NomeMedico;
this.txtEstadoAgenda.Text = agenda.EstadoAgenda.Estado;
String telefoneMascara =
String.Format
(
"({0}) {1}"
, agenda.TelefoneContato.Substring(0, 2)
, agenda.TelefoneContato.Remove(0, 2)
);
this.txtTelefoneContato.Text = telefoneMascara;
this.CarreagarMedicoExecucaoAgenda(agenda.MedicoExecucaoAgenda);
this.CarregarNotificacoesAvenda(agenda);
this.CarregarLogsSms(agenda);
}
catch (Exception e)
{
Log.Create(e);
Email.Send("Agendamento de congelação - falha na aplicação", e);
this.msgDialog.Show
(
"Erro"
, "Não foi possível carregar os registros para edição."
, UserControl.Message.Type.Error
);
}
}
