Exemple #1
0
        public void EliminarRespuesta()
        {
            IRespuestaService respuestaService = new RespuestaService();

            bool resultado = respuestaService.Eliminar(1);

            Assert.IsTrue(resultado);
        }
Exemple #2
0
        public RespuestaService <Paciente> modificarPaciente(Paciente paciente)
        {
            util = new Utilitario();
            try
            {
                Paciente pacienteAModificar = new Paciente()
                {
                    Codigo          = paciente.Codigo,
                    NumeroDocumento = paciente.NumeroDocumento,
                    Nombres         = paciente.Nombres,
                    ApePaterno      = paciente.ApePaterno,
                    ApeMaterno      = paciente.ApeMaterno,
                    Correo          = paciente.Correo,
                    Sexo            = paciente.Sexo,
                    TipoDocumento   = paciente.TipoDocumento,
                    Contrasena      = paciente.Contrasena,
                };
                //Validaciones
                //1) Validar complejidad de la clave
                bool condicion = util.validarClave(paciente.Contrasena);
                if (condicion == false)
                {
                    //Creamos mensaje de ERROR para enviar
                    mensajePaciente = new RespuestaService <Paciente>("La contraseña debe contener al menos una letra mayuscula, una minúscula, un número y mas de 6 digitos",
                                                                      "Advertencia",
                                                                      "Modificar Paciente",
                                                                      "IPaciente",
                                                                      "ValidarClave",
                                                                      pacienteAModificar);

                    return(mensajePaciente);
                }

                // Grabamos Paciente
                Paciente pacienteModificado = PacienteDAO.Modificar(pacienteAModificar);

                //Retornar Clase Mensaje con los datos a mostrar - Flujo Correcto
                mensajePaciente = new RespuestaService <Paciente>("Paciente modificado correctamente",
                                                                  "Satisfactorio",
                                                                  "Modificar Paciente",
                                                                  "IPaciente",
                                                                  "ModificarPaciente",
                                                                  pacienteModificado);

                return(mensajePaciente);
            }
            catch (Exception ex)
            {
                mensajePaciente = new RespuestaService <Paciente>("Error de Sitema :" + ex.ToString(),
                                                                  "Error",
                                                                  "Modificar Paciente",
                                                                  "IPaciente",
                                                                  "Exeption",
                                                                  null);

                return(mensajePaciente);
            }
        }
Exemple #3
0
        public void AgregarRespuesta_SinSolicitud()
        {
            IRespuestaService respuestaService = new RespuestaService();

            int id = respuestaService.Registrar(new Respuesta()
            {
                Usuario = "IWilson"
            });
        }
Exemple #4
0
        public void AgregarRespuesta_SinUsuario()
        {
            IRespuestaService respuestaService = new RespuestaService();

            int id = respuestaService.Registrar(new Respuesta()
            {
                Solicitud = new Solicitud()
                {
                    Id = 1
                }
            });
        }
Exemple #5
0
        public void AgregarRespuesta()
        {
            IRespuestaService respuestaService = new RespuestaService();

            int id = respuestaService.Registrar(new Respuesta()
            {
                Usuario = "IWilson", Solicitud = new Solicitud()
                {
                    Id = 1
                }
            });

            Assert.IsTrue(id > 0);
        }
        public RespuestaService<Paciente> modificarPaciente(Paciente paciente)
        {
            util = new Utilitario();
            try
            {

                Paciente pacienteAModificar = new Paciente()
                {
                    Codigo = paciente.Codigo,
                    NumeroDocumento = paciente.NumeroDocumento,
                    Nombres = paciente.Nombres,
                    ApePaterno = paciente.ApePaterno,
                    ApeMaterno = paciente.ApeMaterno,
                    Correo = paciente.Correo,
                    Sexo = paciente.Sexo,
                    TipoDocumento = paciente.TipoDocumento,
                    Contrasena = paciente.Contrasena,

                };
                //Validaciones
                //1) Validar complejidad de la clave
                bool condicion = util.validarClave(paciente.Contrasena);
                if (condicion == false)
                {
                    //Creamos mensaje de ERROR para enviar
                    mensajePaciente = new RespuestaService<Paciente>("La contraseña debe contener al menos una letra mayuscula, una minúscula, un número y mas de 6 digitos",
                                          "Advertencia",
                                          "Modificar Paciente",
                                          "IPaciente",
                                          "ValidarClave",
                                          pacienteAModificar);

                    return mensajePaciente;
                }

                // Grabamos Paciente
                Paciente pacienteModificado = PacienteDAO.Modificar(pacienteAModificar);

                //Retornar Clase Mensaje con los datos a mostrar - Flujo Correcto
                mensajePaciente = new RespuestaService<Paciente>("Paciente modificado correctamente",
                                    "Satisfactorio",
                                    "Modificar Paciente",
                                    "IPaciente",
                                    "ModificarPaciente",
                                    pacienteModificado);

                return mensajePaciente;
            }
            catch (Exception ex)
            {
                mensajePaciente = new RespuestaService<Paciente>("Error de Sitema :" + ex.ToString(),
                                    "Error",
                                    "Modificar Paciente",
                                    "IPaciente",
                                    "Exeption",
                                    null);

                return mensajePaciente;

            }
        }
        public RespuestaService<Paciente> registrarPaciente(Dominio.Paciente paciente)
        {
            util = new Utilitario();
            try
            {

                string codigoGenerado = util.generarCodigo(paciente);
                Paciente pacienteACrear = new Paciente();
                //Paciente pacienteACrear = new Paciente()
                //{
                pacienteACrear.Codigo = codigoGenerado;
                pacienteACrear.NumeroDocumento = paciente.NumeroDocumento;
                pacienteACrear.Nombres = paciente.Nombres;
                pacienteACrear.ApePaterno = paciente.ApePaterno;
                pacienteACrear.ApeMaterno = paciente.ApeMaterno;
                pacienteACrear.Correo = paciente.Correo;
                pacienteACrear.Sexo = paciente.Sexo;
                pacienteACrear.TipoDocumento = paciente.TipoDocumento;
                pacienteACrear.Contrasena = paciente.Contrasena;

                //};
                //Validaciones
                //1) Validar complejidad de la clave
                bool condicion = util.validarClave(paciente.Contrasena);
                //bool condicion = util.validarClave(pacienteACrear.Contrasena);
                //bool condicion = true;
                if (condicion == false)
                {
                    //Creamos mensaje de ERROR para enviar
                    mensajePaciente = new RespuestaService<Paciente>("La contraseña debe contener al menos una letra mayuscula, una minúscula, un número y mas de 6 digitos",
                                          "Advertencia",
                                          "Registro de Paciente",
                                          "IPaciente",
                                          "ValidarClave",
                                          pacienteACrear);

                    return mensajePaciente;
                }
                //2) Validar paciente no exista
                if (PacienteDAO.Obtener(codigoGenerado) != null)
                {
                    mensajePaciente = new RespuestaService<Paciente>("El paciente que esta intentando crear ya existe",
                                         "Advertencia",
                                         "Registro de Paciente",
                                         "IPaciente",
                                         "ValidarPacienteCreado",
                                         pacienteACrear);

                    return mensajePaciente;
                }

                // Grabamos Paciente
                Paciente pacienteCreado = PacienteDAO.Crear(pacienteACrear);

                //Retornar Clase Mensaje con los datos a mostrar - Flujo Correcto

                mensajePaciente = new RespuestaService<Paciente>("Paciente creado correctamente. Codigo generado:" + codigoGenerado,
                                    "Satisfactorio",
                                    "Registro de Paciente",
                                    "IPaciente",
                                    "CrearPaciente",
                                    pacienteCreado);

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

                return mensajePaciente;
            }
        }
Exemple #8
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);
            }
        }
Exemple #9
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);
            }
        }
Exemple #10
0
        public RespuestaService <Paciente> registrarPaciente(Dominio.Paciente paciente)
        {
            util = new Utilitario();
            try
            {
                string   codigoGenerado = util.generarCodigo(paciente);
                Paciente pacienteACrear = new Paciente();
                //Paciente pacienteACrear = new Paciente()
                //{
                pacienteACrear.Codigo          = codigoGenerado;
                pacienteACrear.NumeroDocumento = paciente.NumeroDocumento;
                pacienteACrear.Nombres         = paciente.Nombres;
                pacienteACrear.ApePaterno      = paciente.ApePaterno;
                pacienteACrear.ApeMaterno      = paciente.ApeMaterno;
                pacienteACrear.Correo          = paciente.Correo;
                pacienteACrear.Sexo            = paciente.Sexo;
                pacienteACrear.TipoDocumento   = paciente.TipoDocumento;
                pacienteACrear.Contrasena      = paciente.Contrasena;

                //};
                //Validaciones
                //1) Validar complejidad de la clave
                bool condicion = util.validarClave(paciente.Contrasena);
                //bool condicion = util.validarClave(pacienteACrear.Contrasena);
                //bool condicion = true;
                if (condicion == false)
                {
                    //Creamos mensaje de ERROR para enviar
                    mensajePaciente = new RespuestaService <Paciente>("La contraseña debe contener al menos una letra mayuscula, una minúscula, un número y mas de 6 digitos",
                                                                      "Advertencia",
                                                                      "Registro de Paciente",
                                                                      "IPaciente",
                                                                      "ValidarClave",
                                                                      pacienteACrear);

                    return(mensajePaciente);
                }
                //2) Validar paciente no exista
                if (PacienteDAO.Obtener(codigoGenerado) != null)
                {
                    mensajePaciente = new RespuestaService <Paciente>("El paciente que esta intentando crear ya existe",
                                                                      "Advertencia",
                                                                      "Registro de Paciente",
                                                                      "IPaciente",
                                                                      "ValidarPacienteCreado",
                                                                      pacienteACrear);

                    return(mensajePaciente);
                }


                // Grabamos Paciente
                Paciente pacienteCreado = PacienteDAO.Crear(pacienteACrear);

                //Retornar Clase Mensaje con los datos a mostrar - Flujo Correcto

                mensajePaciente = new RespuestaService <Paciente>("Paciente creado correctamente. Codigo generado:" + codigoGenerado,
                                                                  "Satisfactorio",
                                                                  "Registro de Paciente",
                                                                  "IPaciente",
                                                                  "CrearPaciente",
                                                                  pacienteCreado);

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

                return(mensajePaciente);
            }
        }
Exemple #11
0
 public RespuestaController(RespuestaService respService)
 {
     this.respService = respService;
 }
Exemple #12
0
 public RespuestasController()
 {
     personaService   = new PersonaService();
     respuestaService = new RespuestaService();
     preguntaService  = new PreguntaService();
 }
Exemple #13
0
        public void EliminarRespuesta_IdInvalido()
        {
            IRespuestaService respuestaService = new RespuestaService();

            bool resultado = respuestaService.Eliminar(10);
        }
        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;
            }
        }
        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;
            }
        }