//EVENTOS CLICK
protected void btnAceptar_Click(object sender, EventArgs e)
{
try
{
Cliente oCliente = new Cliente();
oCliente = oClienteSession;
Abogado oAbgado = new Abogado();
oAbgado.Id = Convert.ToInt32(ddlAbogados.SelectedItem.Value);
Turno oTurno = new Turno();
oTurno.Cliente = oCliente;
oTurno.Abogado = oAbgado;
oTurno.FechaTurno = DateTime.Now;
oTurno.Descripcion = txtDescripcion.Text;
Controller.guardarTurno(oTurno, "Insert");
lblError.Visible = true;
lblError.ForeColor = Color.Green;
lblError.Text = "Se Ha Cargado Correctamente El Turno";
}
catch(Exception)
{
lblError.Visible = true;
lblError.ForeColor = Color.Red;
lblError.Text = "Ocurrio Un Problema Al Cargar El Turno";
}
}
private void btnAction_Click(object sender, EventArgs e)
{
try
{
unTurno = (Turno)grillaHorarios.CurrentRow.DataBoundItem;
unTurno.Codigo_Profesional = unProfesional.Id;
unTurno.Codigo_Especialidad = unaEspecialidad;
unTurno.Codigo_Persona = unAfiliado.Codigo_Persona;
nro_turno = Turnos.AgregarTurno(unTurno);
if (nro_turno != 0)
{
MessageBox.Show("El turno numero " + nro_turno + " se ha registrado con exito!", "Aviso", MessageBoxButtons.OK);
this.Close();
}
else
{
MessageBox.Show("El turno que desea tomar se encuentra ocupado. Seleccione otro horario por favor.", "Error", MessageBoxButtons.OK);
}
}
catch
{
MessageBox.Show("No se ha seleccionado ningun turno, por favor seleccione uno", "Aviso", MessageBoxButtons.OK);
}
}
public virtual Paciente AgregarTurno(Turno turno)
{
if (turno == null) throw new ArgumentNullException("turno");
_turnos.Add(turno);
return this;
}
public Turma criaTurma(String codigo, Disciplina disciplina, Professor professor, Periodo periodo, Turno turno)
{
Turma turma = new Turma();
turma.codigo = codigo;
turma.disciplina = disciplina;
turma.periodo = periodo;
turma.turno = turno;
turma.professor = professor;
return turma;
}
public void si_empiezo_con_un_turno_la_primera_ficha_es_de_tipo_aspa()
{
//Arrange
var turno = new Turno();
//Action
var fichaActual = turno.GetFichaActual();
//Assert
Assert.Equal(Fichas.Aspa,fichaActual);
}
//EVENTOS GRISVIEWTURNOS
protected void GridViewTurnos_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
Turno oTurno = new Turno();
oTurno.Id = int.Parse(e.OldValues["Id"].ToString());
oTurno.Ausente = Convert.ToBoolean(e.NewValues["Ausente"].ToString());
oTurno.Atendido = Convert.ToBoolean(e.NewValues["Atendido"].ToString());
e.NewValues.Clear();
e.NewValues.Add("pTurno", oTurno);
e.NewValues.Add("pOperacion", "Update");
}
public void la_segunda_ficha_es_de_tipo_circulo()
{
//Arrange
var turno = new Turno();
turno.GetFichaActual();
//Action
var fichaActual = turno.GetFichaActual();
//Assert
Assert.Equal(Fichas.Circulo, fichaActual);
}
public void la_tercera_ficha_es_de_tipo_aspa()
{
//Arrange
var turno = new Turno();
turno.GetFichaActual(); //1ª
turno.GetFichaActual(); //2ª
//Action
var fichaActual = turno.GetFichaActual(); //3ª
//Assert
Assert.Equal(Fichas.Aspa, fichaActual);
}
public void al_reiniciar_una_partida_la_primera_ficha_VUELVE_a_ser_un_aspa()
{
//Arrange
var turno = new Turno();
//Action
var fichaActualAntesDeReiniciar = turno.GetFichaActual();
turno.ReiniciarPartida();
var fichaActual = turno.GetFichaActual();
//Assert
Assert.Equal(Fichas.Aspa, fichaActualAntesDeReiniciar);
Assert.Equal(Fichas.Aspa, fichaActual);
}
public void si_añado_una_ficha_a_un_tablero_iniciado_este_contendra_una_ficha_en_la_posicion_indicada()
{
var tablero = new Tablero();
var turno = new Turno();
var ficha = turno.GetFichaActual();
byte fila = 0;
byte columna = 2;
var posicion = new Posicion(fila,columna);
tablero.AddFicha(ficha, posicion);
Assert.Equal(1,tablero.GetNumeroFichas());
Assert.Equal(ficha,tablero.GetFicha(posicion));
}
public void si_todas_las_fichas_de_misma_columna_son_iguales_ganan_esas_fichas()
{
Tablero tablero = new Tablero();
var turno = new Turno();
for (byte i = 0; i < DimensionTableroMenosUno; i++)
{
tablero.AddFicha(turno.GetFichaActual(), new Posicion(i, 1));
tablero.AddFicha(turno.GetFichaActual(), new Posicion(i, 0));
}
Assert.Equal(null, tablero.GetGanador());
var ficha = turno.GetFichaActual();
tablero.AddFicha(ficha, new Posicion ( DimensionTableroMenosUno,1));
Assert.Equal(ficha, tablero.GetGanador());
}
private void btnRealizado_Click(object sender, EventArgs e)
{
TurnoNegocio negocio = new TurnoNegocio();
Turno turno = new Turno();
if (dgvTurnos.RowCount == 0)
{
MessageBox.Show("No hay turnos cargados", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
turno = (Turno)dgvTurnos.CurrentRow.DataBoundItem;
turno.realizado = true;
negocio.TurnoRealizado(turno);
cargarGrillaHoy();
}
}
// GET: Turnos/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Turno turno = await db.Turnos.FindAsync(id);
if (turno == null)
{
return(HttpNotFound());
}
ViewBag.EspecialidadId = new SelectList(db.Especialidades, "Id", "Nombre", turno.EspecialidadId);
ViewBag.MedicoId = new SelectList(db.Medicos, "Id", "Nombre", turno.MedicoId);
ViewBag.ObraSocialId = new SelectList(db.ObrasSociales, "Id", "Nombre", turno.ObraSocialId);
return(View(turno));
}
public bool SeSolapaConTurno(Turno turnoOtorgado)
{
//Los sobreturnos no computan
if (turnoOtorgado.EsSobreTurno) return false;
//El inicio del turno libre se encuentra dentro del período del turno otorgado.
if (FechaTurnoInicial >= turnoOtorgado.FechaTurno && FechaTurnoInicial < turnoOtorgado.FechaTurnoFinal) return true;
//El final del turno libre se encuentra dentro del período del turno otorgado.
if (FechaTurnoFinal > turnoOtorgado.FechaTurno && FechaTurnoFinal <= turnoOtorgado.FechaTurnoFinal) return true;
//El inicio del turno otorgado se encuentra dentro del período del turno libre
if (turnoOtorgado.FechaTurno >= FechaTurnoInicial && turnoOtorgado.FechaTurno < FechaTurnoFinal) return true;
//El inicio del turno otorgado se encuentra dentro del período del turno libre
if (turnoOtorgado.FechaTurnoFinal > FechaTurnoInicial && turnoOtorgado.FechaTurnoFinal <= FechaTurnoFinal) return true;
//No se solapan
return false;
}
private void btnBuscarTurno_Click(object sender, EventArgs e)
{
using (FrmAgendaConsultar frm = new FrmAgendaConsultar(1))
{
frm.AfiliadoBuscador = _afiliado;
frm.ShowDialog(this);
if (frm.TurnoSeleccionado != null)
{
this._turno = frm.TurnoSeleccionado;
tbTurno.Text = _turno.ToString();
btnBuscarTurno.Enabled = false;
this.btnValidarBono.Enabled = true;
this.tbBonoConsulta.Enabled = true;
this.tbBonoConsulta.ReadOnly = false;
}
}
}
// GET: Turno/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Turno turno = db.Turno.Find(id);
if (turno == null)
{
return(HttpNotFound());
}
ViewBag.AfiliadoId = new SelectList(db.Afiliado, "Id", "Nombre", turno.AfiliadoId);
ViewBag.EspecialidadProfesionalId = new SelectList(db.EspecialidadesProfesional.Include(e => e.Especialidad).Include(e => e.Profesional).ToList().Select(o => new { o.Id, Especialidad = string.Format("{0} ({1} {2})", o.Especialidad.descripcion, o.Profesional.Nombre, o.Profesional.Apellido) }).ToList(), "Id", "Especialidad");
ViewBag.reserva = new SelectList(db.TipoReseva.ToList(), "Id", "descripcion");
return(View(turno));
}
public ActionResult Create([Bind(Include = "Id,Fecha,Hora,AfiliadoId,EspecialidadProfesionalId,reserva,Observaciones,createdon,createdby,changedon,changedby,deletedon,deletedby,isdeleted")] Turno turno)
{
if (ModelState.IsValid)
{
db.Turno.Add(turno);
db.SaveChanges();
return(RedirectToAction("Index"));
}
Afiliado afiliado = db.Afiliado.Include(a => a.EstadoCivil).Include(a => a.Plan).Include(a => a.TipoDocumento).Include(a => a.TipoSexo).Where(a => a.isdeleted == false).ToList().Where(o => o.Email == User.Identity.Name).FirstOrDefault();
ViewBag.AfiliadoLogueadoNombreApellido = string.Format("{0} {1} Nº {2} ({3} {4})", afiliado.Nombre, afiliado.Apellido, afiliado.NumeroAfiliado, afiliado.TipoDocumento.descripcion, afiliado.Numero);;
ViewBag.AfiliadoId = new SelectList(db.Afiliado, "Id", "Nombre", turno.AfiliadoId);
ViewBag.EspecialidadProfesionalId = new SelectList(db.EspecialidadesProfesional.Include(e => e.Especialidad).Include(e => e.Profesional).ToList().Select(o => new { o.Id, Especialidad = string.Format("{0} ({1} {2})", o.Especialidad.descripcion, o.Profesional.Nombre, o.Profesional.Apellido) }).ToList(), "Id", "Especialidad");
ViewBag.reserva = new SelectList(db.TipoReseva.ToList(), "Id", "descripcion");
logger.Debug("Se creo un turno");
return(View(turno));
}
protected void btnActualizar_Click(object sender, EventArgs e)
{
try
{
if (Session["NombreUsuario"] != null)
{
DataSet ds = new DataSet();
Turno turno = new Turno();
TurnoRepositorio turnoRepo = new TurnoRepositorio();
LlenarDatos(turno);
ds = turnoRepo.TurnoActualizar(turno);
if (ds.Tables[0].Rows.Count > 0)
{
string msj = ds.Tables[0].Rows[0]["msj"].ToString();
if (msj == "OK")
{
LimpiarControles();
rptTurnos.DataSource = acc.EjecutarScript("EXEC SP_Turnos_Obtener '" + Session["NombreUsuario"].ToString() + "'");
rptTurnos.DataBind();
ClientScript.RegisterStartupScript(this.GetType(), "SweetAlert", "swal('Hecho', 'El turno se actualizó exitosamente', 'success');", true);
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "SweetAlert", "swal('Error','" + msj + "', 'error');", true);
}
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "SweetAlert", "swal('Error','No se pudo actualizar', 'error');", true);
}
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "SweetAlert", "swal('Atención','Debe iniciar sesión para actualizar turno', 'warning');", true);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult> AsignarSobreturno(int?id, int?pacienteId)
{
if (id == null || pacienteId == null)
{
TempData[Application.MessageViewBagName] = new GenericMessageViewModel
{
Message = "No existe la ruta.",
MessageType = GenericMessages.warning
};
return(RedirectToAction("Index"));
}
Turno turno = await db.Turnos.FindAsync(id);
Paciente paciente = await db.Pacientes.FindAsync(pacienteId);
if (turno == null || paciente == null)
{
TempData[Application.MessageViewBagName] = new GenericMessageViewModel
{
Message = "No existe la ruta.",
MessageType = GenericMessages.warning
};
return(RedirectToAction("Index"));
}
Turno nuevoTurno = new Turno();
nuevoTurno.MedicoId = turno.MedicoId;
nuevoTurno.EspecialidadId = turno.EspecialidadId;
nuevoTurno.ObraSocialId = paciente.ObraSocial.Id;
nuevoTurno.PacienteId = paciente.Id;
nuevoTurno.Estado = Estado.Reservado;
nuevoTurno.FechaHora = turno.FechaHora;
nuevoTurno.FechaHoraFin = turno.FechaHoraFin;
nuevoTurno.Costo = paciente.ObraSocial.Tarifas.Where(t => t.EspecialidadId == turno.EspecialidadId).FirstOrDefault().Tarifa;
nuevoTurno.Sobreturno = true;
nuevoTurno.TieneObraSocial = false;
nuevoTurno.Medico = turno.Medico;
nuevoTurno.Especialidad = turno.Especialidad;
nuevoTurno.Paciente = paciente;
nuevoTurno.ObraSocial = paciente.ObraSocial;
return(View(nuevoTurno));
}
public void Update(Turno pTurno)
{
using (SqlConnection cnn = new SqlConnection(GetConnectionString()))
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = cnn;
cmd.CommandText = "UPDATE Turnos " +
"SET Ausente=@Ausente, Atendido=@Atendido " +
"WHERE Id=@Id";
cmd.Parameters.Add(new SqlParameter("@Id", pTurno.Id));
cmd.Parameters.Add(new SqlParameter("@Ausente", pTurno.Ausente));
cmd.Parameters.Add(new SqlParameter("@Atendido", pTurno.Atendido));
cnn.Open();
cmd.ExecuteNonQuery();
}
}
public async Task <IActionResult> _GetMédicosDisponibles(Turno turno)
{
List <Personal> personal = new List <Personal>();
personal = await repo.GetPersonalByTurno(turno);
foreach (Personal p in personal)
{
p.Especialidad = await repo.GetEspecialidadPersonal(p.EspecialidadId);
p.MedicoEspecialidad = p.Especialidad.Nombre + " - " + p.Nombre + " " + p.Apellidos;
}
CitasViewModel vm = new CitasViewModel();
vm.Personal = personal;
return(PartialView(vm));
}
public void cargarViaje(Chofer chofer, float kilometros, Turno turno, DateTime fechaInicio, DateTime fechaFin, Automovil auto, Cliente cliente)
{
SqlConnection conexion = SqlGeneral.nuevaConexion();
SqlCommand cmd = new SqlCommand("INSERT INTO SQLGROUP.Viajes(Viaje_Cant_Kilometros,Viaje_Fecha,Viaje_Fecha_Inic, Viaje_Fecha_Fin, Viaje_Chofer_Id, Viaje_Auto_Id, Viaje_Turno_Id, Viaje_Cliente_Id) " +
" VALUES(@kilometros,@vf,@vfi,@vff,@vchi,SQLGROUP.getAutoId(@vap),@vti,@vci)", conexion);
cmd.Parameters.AddWithValue("kilometros", kilometros);
cmd.Parameters.AddWithValue("vf", fechaInicio);
cmd.Parameters.AddWithValue("vfi", fechaInicio);
cmd.Parameters.AddWithValue("vff", fechaFin);
cmd.Parameters.AddWithValue("vchi", chofer.id);
cmd.Parameters.AddWithValue("vap", auto.patente);
cmd.Parameters.AddWithValue("vti", turno.id);
cmd.Parameters.AddWithValue("vci", cliente.id);
conexion.Open();
cmd.ExecuteNonQuery();
conexion.Close();
}
public void poetry_mode()
{
//Arrange
var tablero = new Tablero();
var turno = new Turno();
var ficha = turno.GetFichaActual();
const byte fila = 0;
const byte columna = 0;
var posicion = new Posicion(fila,columna);
//Action
tablero.
Add(ficha).
En(posicion);
//Assert
Assert.Equal(ficha, tablero.GetFicha(posicion));
}
//helpers
private Turno GetTurnoAnterior(int turnoId)
{
var turno = _db.Set <Turno>().FirstOrDefault(t => t.Id == turnoId);
var turnoAnterior = _db.Set <Turno>()
.Any(t => t.Id != turnoId && t.BarId == turno.BarId && t.FechaInicio < turno.FechaInicio)
? _db.Set <Turno>()
.Where(t => t.Id != turnoId && t.BarId == turno.BarId && t.FechaInicio < turno.FechaInicio)
.OrderBy(t => t.FechaFin).Last()
: null;
if (turnoAnterior == null)
{
turnoAnterior = new Turno {
Id = 0, BarId = 0
};
}
return(turnoAnterior);
}
// GET: Turnoes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Turno turno = db.Turnos.Find(id);
if (turno == null)
{
return(HttpNotFound());
}
ViewBag.PacienteID = new SelectList(db.Pacientes, "Id", "Nombre", turno.PacienteID);
ViewBag.DetallePaciente = db.Pacientes.FirstOrDefault(x => x.Id == turno.PacienteID);
return(View(turno));
}
public ActionResult Edit(Turno turno)
{
this.ViewBag.Medicos = this.db.Medico.ToList();
this.ViewBag.Pacientes = this.db.Paciente.ToList();
try
{
turno.Fecha_Fin = turno.Fecha_Inicio.Add(new TimeSpan(0, 30, 0));
this.db.Turno.Attach(turno);
this.db.Entry(turno).State = System.Data.Entity.EntityState.Modified;
this.db.SaveChanges();
return(RedirectToAction($"../Paciente/Details/{turno.Id_Paciente}"));
}
catch
{
return(RedirectToAction("/Index"));
}
}
protected void btnGuardar_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{ ///Verifica si se trata de un alta o modificacion de protocolo
Turno oRegistro = new Turno();
if (Request["Modifica"].ToString() == "1")
{
oRegistro = (Turno)oRegistro.Get(typeof(Turno), int.Parse(Request["idTurno"].ToString()));
}
Guardar(oRegistro);
if (chkImprimir.Checked)
{
Imprimir(oRegistro);
}
Response.Redirect("TurnoList.aspx", false);
}
}
public override void configurar(IDominio elemento) // Método usado por el Listado de Choferes. Envía el Chofer seleccionado (al que se le realizará la rendicion)
{
if (buscaChofer)
{
Persona chofer = (Persona)elemento;
idChofer = chofer.id;
txtChofer.Text = (chofer.nombre + " " + chofer.apellido);
toolTip1.SetToolTip(txtChofer, String.Format("{0} {1} \nDNI:{2} \nMail:{3}", chofer.nombre, chofer.apellido, chofer.dni, chofer.mail));
buscaChofer = false;
}
else // Entonces busca turno
{
Turno turno = (Turno)elemento;
idTurno = turno.id;
txtTurno.Text = turno.descripcion;
toolTip1.SetToolTip(txtTurno, String.Format("Descripcion:{0}\n Horario:{1} - {2} hs.", turno.descripcion, turno.inicio, turno.fin));
}
}
public JsonResult GrabarTurno(Turno turno)
{
var ok = false;
try
{
_context.Turno.Add(turno);
_context.SaveChanges();
ok = true;
}
catch (Exception e)
{
Console.WriteLine("{0} Excepcion encontrada", e);
}
var jsonResult = new { ok = ok };
return(Json(jsonResult));
}
public async Task <HttpResponseMessage> PostTurno(Turno Turno)
{
try
{
Turno.Activo_Inactivo = true;
db.Turno.Add(Turno);
await db.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
private void btnAceptar_Click(object sender, EventArgs e)
{
if (dgvTurnos.SelectedRows.Count > 0)
{
TurnoDisponible td = dgvTurnos.SelectedRows[0].DataBoundItem as TurnoDisponible;
Turno t = new Turno();
t.IdProfesional = _profesional.IdProfesional;
t.Fecha = mcDesde.SelectionRange.Start;
t.HoraInicio = this.mcDesde.SelectionStart.Add(td.HoraDesde);
t.HoraFin = this.mcDesde.SelectionStart.Add(td.HoraHasta);
t.IdTurno = td.IdTurno;
t.NombreProfesional = _profesional.NombreCompleto;
t.IdAfiliado = td.IdAfiliado;
TurnoSeleccionado = t;
this.Close();
}
}
public void InsertarTurno(Turno turno)
{
conexion.Abir();
SqlCommand comando = new SqlCommand("InsertarTurno", conexion.conexion);
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.AddWithValue("FechaProgramada", turno.FechaProgramada);
comando.Parameters.AddWithValue("HoraProgramada", turno.HoraProgramada);
comando.Parameters.AddWithValue("IdCliente", turno.IdCliente);
comando.Parameters.AddWithValue("Producto", turno.Producto);
comando.Parameters.AddWithValue("Senia", turno.Senia);
comando.Parameters.AddWithValue("Monto", turno.Monto);
comando.ExecuteNonQuery();
conexion.Cerrar();
}
public Consulta getInfo(Turno turno)
{
Consulta consulta = new Consulta();
var row = SqlDataAccess.ExecuteDataRowQuery(ConfigurationManager.ConnectionStrings["StringConexion"].ToString(),
"[SHARPS].GetConsultaInfo", SqlDataAccessArgs
.CreateWith("@turno", turno.Numero)
.Arguments);
//Dado un nombre de perfil, dame el ID
if (row != null)
{
consulta.Enfermedad = row["Enfermedad"].ToString();
consulta.Sintomas = row["Sintomas"].ToString();
consulta.Turno = turno;
consulta.NumeroConsulta = int.Parse(row["Numero_Consulta"].ToString());
}
return(consulta);
}
public static ReservaTurnoViewModel Create(Turno turno)
{
var vm = new ReservaTurnoViewModel
{
Id = turno.Id,
FechaTurnoInicial = turno.FechaTurno,
DuracionTurno= turno.DuracionTurno,
Consultorio =
new InfoViewModel() { Id = turno.Consultorio.Id, Descripcion = turno.Consultorio.Descripcion },
Paciente =
new InfoViewModel() { Id = turno.Paciente.Id, Descripcion = turno.Paciente.Persona.NombreCompleto },
Especialidad =
new InfoViewModel() { Id = turno.Especialidad.Id, Descripcion = turno.Especialidad.Nombre },
Profesional =
new InfoViewModel() { Id = turno.Profesional.Id, Descripcion = turno.Profesional.Persona.NombreCompleto }
};
return vm;
}
protected void btnGuardarDiagnostico_Click(object sender, EventArgs e)
{
int IDT = int.Parse(HF_IDT.Value);
ConnectionDispensario.Modelos.Turno T = Turno.GetTurnoByID(IDT);
if (T != null && txtDiagnostico.Text != null)
{
if (chkControlEmbarazo.Checked == true)
{
T.ActualizarTurno("Control Embarazo", 0, chkControlEmbarazo.Checked);
}
else
{
T.ActualizarTurno(txtDiagnostico.Text, 0, false);
}
redirecttome();
}
}
private void ConfigVars()
{
if (Session[SessionPaciente] == null)
{
form_mode.Value = ModeNone;
btnHistoriaClinica.Visible = false;
}
else
{
form_mode.Value = ModeEdit;
if (!IsPostBack)
{
LoadPaciente();
btnHistoriaClinica.Visible = true;
}
}
if (Request["m"] != null)
{
if (Request["m"] == "e")
{
Paciente t_p = ConnectionDispensario.Modelos.Paciente.Select_Paciente_by_GUI(Request["gui"]);
if (t_p != null)
{
Session.Add(SessionPaciente, t_p);
Response.Redirect("/Gestion-de-pacientes");
}
else
{
}
}
//SACA TURNO
if (Request["m"] == "turno")
{
string IDP = Request["IDP"].ToString();
string IDU = Request["IDU"].ToString();
Turno T = new Turno(int.Parse(IDU), ((Paciente)Session[SessionPaciente]));
T.EstablecerTurno();
Session.Remove(SessionPaciente);
Response.Redirect("/Gestion-de-pacientes");
}
}
}
private void btnAceptar_Click(object sender, EventArgs e)
{
FechaTurno fecha = (FechaTurno)cbxFecha.SelectedItem;
HoraTurno hora = (HoraTurno)cbxHora.SelectedItem;
Turno aux = new Turno();
aux.comentario = tbxObservaciones.Text;
aux.estado = new Estado();
aux.estado.ID = 2;
aux.fecha = new DateTime(fecha.anio, fecha.mes, fecha.dia);
aux.hora = hora.Hora;
aux.medico = new Medico();
aux.medico.dni = HM.dni;
aux.paciente = new Paciente();
aux.paciente.dni = tbxDocumento.Text;
if (TN.ExisteTurno(aux) == true)
{
MessageBox.Show("El turno está ocupado");
return;
}
if (TN.CrearTurno(aux) == false)
{
MessageBox.Show("No se pudo crear el turno");
}
else
{
string data = "Estimado " + aux.paciente.nombre + " " + aux.paciente.apellido;
data += ", le fue asignado un turno para el día " + aux.fecha.ToString() + " a las " + aux.hora.ToString();
MessageBox.Show("El turno se creó correctamente");
if (TN.EnviarMail(aux.paciente.mail, "Asignación de turno", data) == false)
{
MessageBox.Show("Error al enviar el mail");
}
Medico medico = (Medico)cbxMedico.SelectedItem;
Especialidad especialidad = (Especialidad)cbxEspecialidad.SelectedItem;
Cargar_fecha(medico, especialidad);
}
}
public bool IsSesionesSuperpuestas(Turno turno)
{
DateTime hoy = DateTime.Now;
//DateTime minDate = turno.Sesions.Min(x => x.FechaHora);
//DateTime maxDate = turno.Sesions.Max(x => x.FechaHora);
hoy = hoy.AddHours(-1 * hoy.Hour).AddMinutes(-1 * hoy.Minute);
turno.Sesions.ToList()
.ForEach(s =>
{
s.FechaHora = s.FechaHora.AddHours(-1 * s.FechaHora.Hour).AddMinutes(-1 * s.FechaHora.Minute);
});
try
{
var sesiones = turno.Sesions
.Where(s => EstadoSesionCondicion.Ocupado.Contains((EstadoSesion)s.Estado) &&
s.FechaHora >= hoy)
.Select(s => s.FechaHora)
.Distinct()
.ToList();
//var sesiones = (turno.Sesions
//.Where(s => EstadoSesionCondicion.Ocupado.Contains((EstadoSesion)s.Estado)
//&& DbFunctions.TruncateTime(s.FechaHora) >= DbFunctions.TruncateTime(hoy))
//.Select(s => s.FechaHora))
//.Distinct()).ToList();
var turnos = unitOfWork.RepoTurno.FindBy(x => x.ID != turno.ID && x.Estado == (int)EstadoTurno.Confirmado &&
x.PacienteID == turno.PacienteID &&
x.Sesions.Where(s => EstadoSesionCondicion.Ocupado.Contains((EstadoSesion)s.Estado) && sesiones.Contains(DbFunctions.TruncateTime(s.FechaHora).Value))
.Count() > 0
);
return(turnos.Count() > 0);
}
catch
{
return(false);
}
}
private async void FrmTurno_Shown(object sender, EventArgs e)
{
try
{
if (Model.State == EntityState.Update)
{
Turno turno = await Model.GetListaTurno(Model.IdTurno);
List <TurnoDias> lista = turno.DatosValor.ToList();
string hora = "";
foreach (var item in lista)
{
hora = "";
string nombre = item.NombreDia;
var Info = (from inf in lista
where inf.NombreDia == nombre
select inf).ToList();
if (Info.Count > 1)
{
foreach (var item2 in Info)
{
hora += item2.HoraEntrada + "\r\n a\r\n" + item2.HoraSalida + "\r\n\r\n";
}
}
else
{
hora = item.HoraEntrada + "\r\n a\r\n" + item.HoraSalida + "\r\n\r\n";
}
horarioDesignV21.AgregarHora((DaysHour)GetNumDia(item.NombreDia), hora);
Model.ListaValores.Add(new TurnoDias
{
NombreDia = item.NombreDia,
HoraEntrada = item.HoraEntrada,
HoraSalida = item.HoraSalida
});
}
}
IniciarBinding();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que obtiene los turnos correspondientes a un horario de un semestre dado
/// </summary>
/// <param name="idSemestre">Id del semestre a buscar un horario</param>
/// <param name="idLugar">Id del lugar que se quiere ver su horario</param>
/// <returns>Retorna una lista de objetos Turno</returns>
public List <Turno> obtenerTurnosHorarios(int idSemestre, int idLugar)
{
List <Turno> resultado = new List <Turno>();
Turno turno;
SqlCommand consultar = new SqlCommand("SP_HOR_ConsultarTurnos", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[2];
parametros[0] = new SqlParameter("@idSemestre", SqlDbType.Int);
parametros[0].Value = idSemestre;
parametros[1] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[1].Value = idLugar;
consultar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consultar.ExecuteReader();
while (reader.Read())
{
turno = new Turno();
turno.IdTurno = reader.GetInt32(0);
turno.Dia = reader.GetSqlChars(1).Value[0];
turno.HoraInicio = Convert.ToDateTime(reader.GetTimeSpan(2).ToString());
turno.HoraFinal = Convert.ToDateTime(reader.GetTimeSpan(3).ToString());
turno.NombrePersona = reader.GetString(4);
resultado.Add(turno);
}
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
if (listBox1.Items.Count > 0)
{
MisTurnos_button_iniciar.Enabled = true;
MisTurnos_button_borrar.Enabled = true;
turnoSeleccionado = (Turno)listBox1.SelectedItem;
}
else
{
turnoSeleccionado = null;
}
}catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task <ActionResult> agregarTurno([FromBody] Turno turno)
{
ObjectResult result;
int resultado;
try
{
resultado = await _bsTurno.agregaTurnoJsonAsync(turno);
result = Ok(resultado == 1 ? "Registro exitoso ": "Intente nuevamente");
}
catch (Exception ex)
{
resultado = 0;
result = StatusCode(StatusCodes.Status500InternalServerError, resultado);
_logger.LogInformation($"Ha ocurrido un error: {ex.Message.ToString()}");
}
return(result);
}
public static Turno CalcularTurnoAFecha(DateTime fecha)
{
Turno turno = Turno.Mañana;
// 6 - 14 14 - 22 22 - 6
if (fecha.Hour >= comienzoTurnoMañana && fecha.Hour < comienzoTurnoTarde)
{
turno = Turno.Mañana;
}
else if (fecha.Hour >= comienzoTurnoTarde && fecha.Hour < comienzoTurnoNoche)
{
turno = Turno.Tarde;
}
else if (fecha.Hour >= comienzoTurnoNoche && fecha.Hour < comienzoTurnoMañana)
{
turno = Turno.Noche;
}
return(turno);
}
private void Anular(object p)
{
if (Session["idUsuario"] != null)
{
Usuario oUser = new Usuario();
Turno oRegistro = new Turno();
oRegistro = (Turno)oRegistro.Get(typeof(Turno), int.Parse(p.ToString()));
oRegistro.Baja = true;
oRegistro.IdUsuarioRegistro = (Usuario)oUser.Get(typeof(Usuario), int.Parse(Session["idUsuario"].ToString()));
oRegistro.FechaRegistro = DateTime.Now;
oRegistro.Save();
Actualizar();
}
else
{
Response.Redirect("../FinSesion.aspx", false);
}
}
public void Alterar(Turno turno)
{
try
{
Turno turnoAux = new Turno();
turnoAux.ID = turno.ID;
List<Turno> resultado = this.Consultar(turnoAux, TipoPesquisa.E);
if (resultado == null || resultado.Count == 0)
throw new TurnoNaoAlteradoExcecao();
turnoAux = resultado[0];
turnoAux.Nome = turno.Nome;
turnoAux.Status = turno.Status;
Confirmar();
}
catch (Exception)
{
throw new TurnoNaoAlteradoExcecao();
}
}
public void generarLanzamientos(string[] lanzamientos)
{
for (int i = 0; i < lanzamientos.Length; i += 2)
{
if (i < 18)
{
if (i % 2 == 0)
{
Turno turno = new Turno();
turno.acumulado = 0;
turno.Lanzamientos = lanzamientos_Para_Turno(lanzamientos[i], lanzamientos[i + 1], null);
nuevoTurno(turno);
}
}
else
{
Turno turno = new Turno();
turno.acumulado = 0;
turno.Lanzamientos = lanzamientos_Para_Turno(lanzamientos[i], lanzamientos[i + 1], lanzamientos[i+2]);
nuevoTurno(turno);
break;
}
}
}
/// <summary>
/// Añade un Turno a la Actividad_a
/// Los turnos están ordenados de forma creciente
/// </summary>
/// <param name="turnonuevo">Turno que se desea añadir</param>
public void AddTurno(Turno turnonuevo)
{
bool insertado = false;
turnonuevo.Actividad = this;
AsignarCodigo(turnonuevo);
//turnonuevo.Codigo = codigoturno;
for (int i = 0; i < turnos.Count; i++) {
if (turnos[i].HoraInicio > turnonuevo.HoraInicio) {
turnos.Insert(i, turnonuevo);
insertado = true;
break;
}
}
if (!insertado)
turnos.Add(turnonuevo);
//turnonuevo.Codigo++;
}
private void calendar1_ItemDeleted(object sender, CalendarItemEventArgs e)
{
Turno objTurno = new Turno();
objTurno.setDni(e.Item.Tag.ToString());
objTurno.setMatricula(this.vOutlookNavPane1.SelectedItem.Text);
objTurno.setFecha(e.Item.Date);
objTurno.EliminarTurno();
}
// FILTRA LOS TURNOS POR DOCTOR SELECCIONADO
private void llenarSelectivo()
{
Turno objTurno = new Turno();
this.calendar1.Items.Clear();
objTurno.setMatricula(this.vOutlookNavPane1.SelectedItem.Text);
ArrayList col = new ArrayList();
col = objTurno.TurnosDoctor();
for (int i = 0; i < col.Count; i++)
{
objTurno = (Turno)col[i];
CalendarItem objItems = new CalendarItem(this.calendar1, objTurno.getFecha(), objTurno.getDuracion(), objTurno.getApellido() + " " + objTurno.getNombre());
objItems.Tag = objTurno.getDni();
this.calendar1.Items.Add(objItems);
}
}
/// <summary>
/// Inserta un turno Ordenado en un determinado dia
/// </summary>
/// <param name="item">Turno que se quiere insertar </param>
/// <param name="dia"> Dia en el que se quiere insertar </param>
private void insertarOrdenado(Turno item, int dia)
{
int i = 0;
bool insertado = false;
for (i = 0; i < arrayTurnos[dia].Count; i++)
{
if (arrayTurnos[dia][i].HoraInicio > item.HoraInicio)
{
arrayTurnos[dia].Insert(i, item);
insertado = true;
break;
}
}
if (!insertado)
arrayTurnos[dia].Add(item);
}
public void Excluir(Turno turno)
{
try
{
Turno turnoAux = new Turno();
turnoAux.ID = turno.ID;
List<Turno> resultado = this.Consultar(turnoAux, TipoPesquisa.E);
if (resultado == null || resultado.Count == 0)
throw new TurnoNaoExcluidoExcecao();
turnoAux = resultado[0];
db.Turno.DeleteOnSubmit(turnoAux);
}
catch (Exception)
{
throw new TurnoNaoExcluidoExcecao();
}
}
/// <summary>
/// Añade un Turno al Horario
/// </summary>
/// <param name="turno">Turno que se desea añadir</param>
public void AddTurno(Turno turno)
{
switch (turno.Dia)
{
case dias.L:
CheckSolapamiento(turno, 0);
insertarOrdenado(turno, 0);
break;
case dias.M:
CheckSolapamiento(turno, 1);
insertarOrdenado(turno, 1);
break;
case dias.X:
CheckSolapamiento(turno, 2);
insertarOrdenado(turno, 2);
break;
case dias.J:
CheckSolapamiento(turno, 3);
insertarOrdenado(turno, 3);
break;
case dias.V:
CheckSolapamiento(turno, 4);
insertarOrdenado(turno, 4);
break;
case dias.S:
CheckSolapamiento(turno, 5);
insertarOrdenado(turno, 5);
break;
case dias.D:
CheckSolapamiento(turno, 6);
insertarOrdenado(turno, 6);
break;
}
}
/// <summary>
/// Comprueba si un turno se solapa dado un dia
/// </summary>
/// <param name="turno">Turno que se quiere comprobar</param>
/// <param name="dia">Dia en el que se quiere hacer la comprobación</param>
private void CheckSolapamiento(Turno turno, int dia)
{
foreach (Turno item in arrayTurnos[dia])
{
item.Superpone(turno);
}
}
public void Incluir(Turno turno)
{
try
{
db.Turno.InsertOnSubmit(turno);
}
catch (Exception)
{
throw new TurnoNaoIncluidoExcecao();
}
}
public Juego()
{
Turno = new Turno();
Tablero = new Tablero();
}
public JsonResult RegistrarAsignacion(string turno, string punto, string idV, string ini, string fin)
{
//if (Session["ErrorAsignacion"] != null) Session["ErrorAsignacion"] = null;
string m1;
CuentaUsuario vend;
int cpv;
DateTime dt1 = DateTime.Parse(ini);
DateTime dt2 = DateTime.Parse(fin);
DateTime di = dt1;
DateTime dai = dt1;
int idt = int.Parse(turno);
TurnoSistema ts2 = db.TurnoSistema.Find(idt);
TimeSpan ti1 = TimeSpan.Parse(ts2.horIni);
TimeSpan ti2 = TimeSpan.Parse(ts2.horFin);
int idp = int.Parse(punto);
TimeSpan ts = dt2.Subtract(dt1);
TimeSpan hh = DateTime.Now.TimeOfDay;
int nd = (int)ts.Days;
nd = nd + 1;
int idPol = 5;
int idPol2 = 7;
int limite = (int)db.Politicas.Find(idPol).valor;
int limite2 = (int)db.Politicas.Find(idPol2).valor;
if (dt1.Date < DateTime.Now.Date) return Json("la fecha debe ser superior de hoy", JsonRequestBehavior.AllowGet);
if ((dt1.Date == DateTime.Now.Date) && (hh > ti2)) return Json("la Hora a asignar debe ser superior a la hora actual", JsonRequestBehavior.AllowGet);
if (dt1.Date > dt2.Date) return Json("Fecha inicio debe ser menor que fecha fin", JsonRequestBehavior.AllowGet);
if (nd > limite) return Json("No puedo asignar a la vez mas de " + limite + " turnos de manera seguida", JsonRequestBehavior.AllowGet);
//int cruce = 0;
for (int j = 0; j < nd; j++)
{
List<Turno> ltur = db.Turno.Where(c => c.codPuntoVenta == idp && c.codTurnoSis == idt && di == c.fecha).ToList();
if (ltur.Count + 1 > limite2)
{
//Session["nError"] = 1;
//TempData["ErrorAsignacion"] = "Cruce con el usuario " + ltur.First().usuario + " para el dia " + di;
//return RedirectToAction("Asignacion", "CuentaUsuario");
string mensaje = "No puede haber mas de " + limite2 + " vendedores para el dia " + di.ToString("dd/MM/yyyy");
return Json(mensaje, JsonRequestBehavior.AllowGet);
}
di = di.AddDays(1);
}
//int cruce1 = 0;
List<Turno> ltur2 = db.Turno.Where(c => c.codPuntoVenta == idp && c.codTurnoSis == idt && dai == c.fecha && c.usuario == idV).ToList();
if (ltur2.Count > 0)
{
return Json("Este usuario ya tiene asignado un turno para esta fecha , punto de venta y hora", JsonRequestBehavior.AllowGet);
}
List<Turno> ltur3 = db.Turno.Where(c => c.codTurnoSis == idt && dai == c.fecha && c.usuario == idV).ToList();
if (ltur3.Count > 0)
{
return Json("Este usuario ya tiene asignado un turno para esta fecha y hora en otro punto de venta", JsonRequestBehavior.AllowGet);
}
for (int j = 0; j < nd; j++)
{
Turno ntur = new Turno();
ntur.codPuntoVenta = idp;
ntur.codTurnoSis = idt;
ntur.estado = "Pendiente";
ntur.estadoCaja = "Pendiente";
ntur.fecha = dai;
ntur.MontoFinDolares = 0;
ntur.MontoFinSoles = 0;
ntur.MontoInicioDolares = 0;
ntur.MontoInicioSoles = 0;
ntur.usuario = idV;
db.Turno.Add(ntur);
db.SaveChanges();
dai = dai.AddDays(1);
}
DateTime hoy = DateTime.Now.Date;
TimeSpan hh2 = DateTime.Now.TimeOfDay;
List<Turno> listatuvend = db.Turno.AsNoTracking().Where(c => c.usuario == idV && c.fecha >= hoy && c.estado == "Pendiente" && c.estadoCaja == "Pendiente").ToList();
List<Turno> listatuvend2 = listatuvend.Where(c => c.fecha >= hoy || (c.fecha == hoy && TimeSpan.Parse(c.TurnoSistema.horIni) > hh2)).ToList();
Session["ListaTurnoVendedor"] = listatuvend2;
return Json("Registro Correcto", JsonRequestBehavior.AllowGet);
}
public List<Turno> Consultar(Turno turno, TipoPesquisa tipoPesquisa)
{
List<Turno> resultado = Consultar();
switch (tipoPesquisa)
{
#region Case E
case TipoPesquisa.E:
{
if (turno.ID != 0)
{
resultado = ((from t in resultado
where
t.ID == turno.ID
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (!string.IsNullOrEmpty(turno.Nome))
{
resultado = ((from t in resultado
where
t.Nome.Contains(turno.Nome)
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (turno.Status.HasValue)
{
resultado = ((from t in resultado
where
t.Status.HasValue && t.Status.Value == turno.Status.Value
select t).ToList());
resultado = resultado.Distinct().ToList();
}
break;
}
#endregion
#region Case Ou
case TipoPesquisa.Ou:
{
if (turno.ID != 0)
{
resultado.AddRange((from t in Consultar()
where
t.ID == turno.ID
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (!string.IsNullOrEmpty(turno.Nome))
{
resultado.AddRange((from t in Consultar()
where
t.Nome.Contains(turno.Nome)
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (turno.Status.HasValue)
{
resultado.AddRange((from t in Consultar()
where
t.Status.HasValue && t.Status.Value == turno.Status.Value
select t).ToList());
resultado = resultado.Distinct().ToList();
}
break;
}
#endregion
default:
break;
}
return resultado;
}
private void calendar1_ItemCreated(object sender, CalendarItemCancelEventArgs e)
{
Turno objTurno = new Turno();
// SE CREA EL TURNO
// NO HA SIDO AVISADO - NO HA ASISTIDO
objTurno.setDni(e.Item.Text);
objTurno.setFecha(e.Item.Date);
objTurno.setDuracion(e.Item.Duration);
objTurno.setMatricula(this.vOutlookNavPane1.SelectedItem.Text);
objTurno.setAviso(0);
objTurno.setAsistencia(0);
if (objTurno.ExisteTurno())
{
// EL TURNO YA FUE DADO
MessageBox.Show("El turno se dio a otro paciente.", "Advertencia");
this.calendar1.Items.Remove(e.Item);
}
else
{
// EL TURNO ESTA LIBRE
objTurno.NuevoTurno();
}
this.llenarSelectivo();
}
private void calendar1_ItemClick(object sender, CalendarItemEventArgs e)
{
// CONFIRMAR AVISO POR SMS
Turno objTurno = new Turno();
objTurno.setDni(e.Item.Tag.ToString());
objTurno.setFecha(e.Item.Date);
objTurno.DatosTurno();
// CON ESTA CONDICION MUESTRO DIALOGO DE CONFIRMACION ASISTENCIA
// O DIALOGO DE ENVIO DE SMS
if(e.Item.Date.ToShortDateString() == DateTime.Now.ToShortDateString())
{
// EL DIA ACTUAL ES IGUAL AL TURNO
if (MessageBox.Show("Confirma la asistencia del Paciente.", "Confirmar Asistencia", MessageBoxButtons.OKCancel) == DialogResult.OK)
{
objTurno.ConfirmarAsistencia();
}
}
else
{
//EL DIA ACTUAL NO ES LA FECHA DEL TURNO
if (MessageBox.Show("Enviar SMS recordatorio al Paciente.", "Envio de SMS", MessageBoxButtons.OKCancel) == DialogResult.OK)
{
objTurno.EnviarSMS();
}
}
}
private void nuevoTurno(Turno turno)
{
Turnos.Add(turno);
}
