コード例 #1
0
 public void LiberarCita(Cita cita)
 {
     string sql = "UPDATE TReservaCita SET ESTADO=0 WHERE codigo=@cod";
     using (SqlConnection con = new SqlConnection(ConexionUtil.Cadena))
     {
         con.Open();
         using (SqlCommand com = new SqlCommand(sql, con))
         {
             com.Parameters.Add(new SqlParameter("@cod", cita.Codigo));
             com.ExecuteNonQuery();
         }
     }
 }
コード例 #2
0
        public void ActualizarEstado(Cita citaCreada,bool estado)
        {
            string sql="";

            if(estado==true)
             sql = "UPDATE THorarioOdontologo SET estado = 1 where codigoTHorario = @codHor and codigoTOdontologo= @codOdont";
            else
             sql = "UPDATE THorarioOdontologo SET estado = 0 where codigoTHorario = @codHor and codigoTOdontologo= @codOdont";

            using (SqlConnection con = new SqlConnection(ConexionUtil.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@codHor", citaCreada.CodigoHorario));
                    com.Parameters.Add(new SqlParameter("@codOdont", citaCreada.CodigoOdontologo));
                    com.ExecuteNonQuery();
                }
            }
        }
コード例 #3
0
 public Cita Crear(Cita citaACrear)
 {
     int codigo = 0;
     Cita citaCreado = null;
        // string sql = "INSERT INTO TReservaCita VALUES (@fecha, @codEps,@codPac,@codHor,@estado)  SELECT @@IDENTITY";
     string sql = "INSERT INTO TReservaCita VALUES (@fecha, @codEps,@codPac,@codHor,@codOdont,@estado)  SELECT @@IDENTITY";
     using (SqlConnection con = new SqlConnection(ConexionUtil.Cadena))
     {
         con.Open();
         using (SqlCommand com = new SqlCommand(sql, con))
         {
             com.Parameters.Add(new SqlParameter("@fecha", citaACrear.FechaReserva));
             com.Parameters.Add(new SqlParameter("@codEps", citaACrear.CodigoEspecialidad));
             com.Parameters.Add(new SqlParameter("@codPac", citaACrear.CodigoPaciente));
             com.Parameters.Add(new SqlParameter("@codHor", citaACrear.CodigoHorario));
             com.Parameters.Add(new SqlParameter("@codOdont", citaACrear.CodigoOdontologo));
             com.Parameters.Add(new SqlParameter("@estado", citaACrear.Estado));
             codigo = Int32.Parse(com.ExecuteScalar().ToString());
         }
     }
     citaCreado = Obtener(codigo);
     return citaCreado;
 }
コード例 #4
0
 public List<Cita> ListarRolPacienteAdministrador(Cita cita)
 {
     List<Cita> citasEncontrados = new List<Cita>();
     Cita citaEncontrado = null;
     string sql = "SELECT * FROM TReservaCita where  CodigoEspecialidad = @codesp and Estado=1 and CodigoPaciente = @codpac ";
     using (SqlConnection con = new SqlConnection(ConexionUtil.Cadena))
     {
         con.Open();
         using (SqlCommand com = new SqlCommand(sql, con))
         {
             com.Parameters.Add(new SqlParameter("@codesp", cita.CodigoEspecialidad));
             com.Parameters.Add(new SqlParameter("@codpac", cita.CodigoPaciente));
             using (SqlDataReader resultado = com.ExecuteReader())
             {
                 while (resultado.Read())
                 {
                     citaEncontrado = new Cita()
                     {
                         Codigo = (int)resultado["Codigo"],
                         FechaReserva = (DateTime)resultado["FechaReserva"],
                         CodigoEspecialidad = (int)resultado["CodigoEspecialidad"],
                         CodigoPaciente = (string)resultado["CodigoPaciente"],
                         //  CodigoHorarioOdontologo = (int)resultado["CodigoHorarioOdontologo"],
                         CodigoHorario = (int)resultado["CodigoHorario"],
                         CodigoOdontologo = (string)resultado["CodigoOdontologo"],
                         Estado = (bool)resultado["Estado"],
                     };
                     citasEncontrados.Add(citaEncontrado);
                 }
             }
         }
     }
     return citasEncontrados;
 }
コード例 #5
0
        public Cita Modificar(Cita citaAModificar)
        {
            Cita citaModificado = null;
              //  string sql = "UPDATE TReservaCita SET FechaReserva=@fecha,CodigoEspecialidad=@codEsp,CodigoHorarioOdontologo=@codHor WHERE Codigo=@cod";
            string sql = "UPDATE TReservaCita SET FechaReserva=@fecha,CodigoEspecialidad=@codEsp,CodigoHorario=@codHor,CodigoOdontologo=@codOdont WHERE Codigo=@cod";
            using (SqlConnection con = new SqlConnection(ConexionUtil.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@cod", citaAModificar.Codigo));
                    com.Parameters.Add(new SqlParameter("@fecha", citaAModificar.FechaReserva));
                    com.Parameters.Add(new SqlParameter("@codEsp", citaAModificar.CodigoEspecialidad));
                    com.Parameters.Add(new SqlParameter("@codHor", citaAModificar.CodigoHorario));
                    com.Parameters.Add(new SqlParameter("@codOdont", citaAModificar.CodigoOdontologo));

                    com.ExecuteNonQuery();
                }
            }
            citaModificado = Obtener(citaAModificar.Codigo);
            return citaModificado;
        }
コード例 #6
0
 public Cita ObtenerUltimaCitaPaciente(Cita cita)
 {
     Cita citaEncontrado = null;
     string sql = "SELECT TOP 1 * FROM TReservaCita WHERE codigoPaciente=@codpaciente and Estado =1  order by Codigo desc";
     using (SqlConnection con = new SqlConnection(ConexionUtil.Cadena))
     {
         con.Open();
         using (SqlCommand com = new SqlCommand(sql, con))
         {
             com.Parameters.Add(new SqlParameter("@codpaciente", cita.CodigoPaciente));
             using (SqlDataReader resultado = com.ExecuteReader())
             {
                 if (resultado.Read())
                 {
                     citaEncontrado = new Cita()
                     {
                         Codigo = (int)resultado["Codigo"],
                         FechaReserva = (DateTime)resultado["FechaReserva"],
                         CodigoEspecialidad = (int)resultado["CodigoEspecialidad"],
                         CodigoPaciente = (string)resultado["CodigoPaciente"],
                         CodigoHorario = (int)resultado["CodigoHorario"],
                         CodigoOdontologo = (string)resultado["CodigoOdontologo"],
                     //    CodigoHorarioOdontologo = (int)resultado["CodigoHorarioOdontologo"],
                         Estado = (bool)resultado["Estado"],
                     };
                 }
             }
         }
     }
     return citaEncontrado;
 }
コード例 #7
0
        public RespuestaService<Cita> modificarCita(Cita cita)
        {
            util = new Utilitario();
            try
            {
                Cita citaAModificar = new Cita();

                citaAModificar.Codigo = cita.Codigo;
                citaAModificar.FechaReserva = cita.FechaReserva;
                citaAModificar.CodigoEspecialidad = cita.CodigoEspecialidad;
                citaAModificar.CodigoPaciente = cita.CodigoPaciente;
               // citaAModificar.CodigoHorarioOdontologo = cita.CodigoHorarioOdontologo;
                citaAModificar.CodigoHorario = cita.CodigoHorario;
                citaAModificar.CodigoOdontologo = cita.CodigoOdontologo;
                citaAModificar.Estado = Constantes.VERDADERO;

                //Validaciones
                //1) Validar solo puede realizar una cita con 7 días de anticipación
                if (util.validarDiasAnticipacionCita(citaAModificar.FechaReserva) > 7)
                {
                    //Creamos mensaje de ADVERTENCIA para enviar
                    mensajeCita = new RespuestaService<Cita>("Solo puede reservar una cita con 7 días de anticipación.",
                                          "Advertencia",
                                          "Registro de Cita",
                                          "ICitas",
                                          "validarDiasAnticipacionCita",
                                          citaAModificar);

                    return mensajeCita;
                }
                Cita citaActual = CitaDAO.Obtener(citaAModificar.Codigo);
                Cita citaModificado = CitaDAO.Modificar(citaAModificar);

                if (citaActual.CodigoHorario != citaAModificar.CodigoHorario ||
                    citaActual.CodigoOdontologo != citaAModificar.CodigoOdontologo)
                {
                    //cambiado de horario u odontologo  - Liberar el horario u odontologo
                    HorarioDAO.ActualizarEstado(citaActual, true);
                    HorarioDAO.ActualizarEstado(citaModificado, false);
                }

                //Retornar Clase Mensaje con los datos a mostrar - Flujo Correcto
                mensajeCita = new RespuestaService<Cita>("Cita modificada correctamente. Codigo generado:" + cita.Codigo + " Nueva Fecha: " + citaModificado.FechaReserva,
                                    "Satisfactorio",
                                    "Registro de Cita",
                                    "ICitas",
                                    "CrearCita",
                                    citaModificado);

                return mensajeCita;
            }
            catch (Exception ex)
            {
                mensajeCita = new RespuestaService<Cita>("Error de Sitema :" + ex.ToString(),
                                    "Error",
                                    "Modificar Cita",
                                    "ICitas",
                                    "Excepcion",
                                    null);

                return mensajeCita;
            }
        }
コード例 #8
0
 public void cancelarCita(Cita cita)
 {
     CitaDAO.LiberarCita(cita);
 }
コード例 #9
0
 private void enviarDatosACola(Cita cita)
 {
     // 1. Enviamos la nota original vía la cola de entrada del servidor (In)
     string rutaColaIn = @".\private$\CitasClinica";
     if (!MessageQueue.Exists(rutaColaIn))
         MessageQueue.Create(rutaColaIn);
     MessageQueue colaIn = new MessageQueue(rutaColaIn);
     Message mensajeIn = new Message();
     mensajeIn.Label = "Cita";
     mensajeIn.Body = new Cita() { Codigo =cita.Codigo, CodigoPaciente = cita.CodigoPaciente, FechaReserva = cita.FechaReserva , CodigoEspecialidad=cita.CodigoEspecialidad,
                                   CodigoOdontologo =cita.CodigoOdontologo,CodigoHorario=cita.CodigoHorario,Estado=cita.Estado};
     colaIn.Send(mensajeIn);
 }
コード例 #10
0
 private string enviarCorreo(Cita citaBE)
 {
     return "CORREO ENVIADO OK";
 }
コード例 #11
0
        public RespuestaService<Cita> registrarCita(Cita cita)
        {
            util = new Utilitario();
            try
            {
                Cita citaACrear = new Cita();

                citaACrear.FechaReserva = cita.FechaReserva;
                citaACrear.CodigoEspecialidad = cita.CodigoEspecialidad;
                citaACrear.CodigoPaciente = cita.CodigoPaciente;
              //  citaACrear.CodigoHorarioOdontologo = cita.CodigoHorarioOdontologo;
                citaACrear.CodigoHorario = cita.CodigoHorario;
                citaACrear.CodigoOdontologo = cita.CodigoOdontologo;
                citaACrear.Estado = Constantes.VERDADERO;

                //Validaciones
                //1) Validar solo puede realizar una cita cada 24 horas

                //Obtenenemos ultima fecha de reserva del paciente a registrar
                Cita citaPrevia = CitaDAO.ObtenerUltimaCitaPaciente(citaACrear);
                if (citaPrevia != null)
                {
                    int condicion = util.validarRangoHorasCita(citaPrevia.FechaReserva, citaACrear.FechaReserva);
                    if (condicion < 1)
                    {
                        //Creamos mensaje de ADVERTENCIA para enviar
                        mensajeCita = new RespuestaService<Cita>("Para realizar una Reserva de cita debe pasar 24 horas desde la última que registró",
                                              "Advertencia",
                                              "Registro de Cita",
                                              "ICitas",
                                              "validarRangoHorasCita",
                                              citaACrear);

                        return mensajeCita;
                    }
                }

                //Validaciones
                //2) Validar solo puede realizar una cita con 7 días de anticipación

                if (util.validarDiasAnticipacionCita(citaACrear.FechaReserva) > 7)
                {
                    //Creamos mensaje de ADVERTENCIA para enviar
                    mensajeCita = new RespuestaService<Cita>("Solo puede reservar una cita con 7 días de anticipación.",
                                          "Advertencia",
                                          "Registro de Cita",
                                          "ICitas",
                                          "validarDiasAnticipacionCita",
                                          citaACrear);

                    return mensajeCita;
                }

                // Grabamos una cita
                Cita citaCreado = CitaDAO.Crear(citaACrear);

                //Actualizamos el estado del horario para que no pueda ser elegido
                HorarioDAO.ActualizarEstado(citaCreado,false);

                //Retornar Clase Mensaje con los datos a mostrar - Flujo Correcto
                mensajeCita = new RespuestaService<Cita>("Cita registrada correctamente. Codigo generado:" + cita.Codigo + " Fecha:" + citaCreado.FechaReserva,
                                    "Satisfactorio",
                                    "Registro de Cita",
                                    "ICitas",
                                    "CrearCita",
                                    citaCreado);

                enviarDatosACola(citaCreado);

                return mensajeCita;
            }
            catch (Exception ex)
            {
                mensajeCita = new RespuestaService<Cita>("Error de Sitema :" + ex.ToString(),
                                    "Error",
                                    "Registro de Cita",
                                    "ICitas",
                                    "Excepcion",
                                    null);

                return mensajeCita;
            }
        }