public static async Task <Medico> ValidarMedico()
{
MedicoBL bl = new MedicoBL();
Console.WriteLine("Ingrese Usuario");
string CMP = Console.ReadLine();
Console.WriteLine("Ingrese Contraseña");
string Dni = Console.ReadLine();
var listaMedicos = await GetMedicos();
if (listaMedicos.Count != 0)
{
foreach (var item in listaMedicos)
{
if (item.CMP == CMP && item.Dni == Dni)
{
return(item);
}
}
return(null);
}
else
{
if (CMP == "admin" && Dni == "1234")
{
return(null);
}
else
{
return(null);
}
}
}
public ActionResult Excluir(int id)
{
var medico = MedicoBL.BuscaMedicoPorId(id);
MedicoBL.DeletaMedico(id);
return(RedirectToAction("Index"));
}
public dynamic Put(Medico medico)
{
var result = MedicoBL.Atualizar(medico);
if (result)
{
return(new { Status = "S", Message = "Sucesso" });
}
return(new { Status = "E", Message = "Erro" });
}
public dynamic Delete(int id)
{
var result = MedicoBL.Excluir(id);
if (result)
{
return(new { Status = "S", Message = "Sucesso" });
}
return(new { Status = "E", Message = "Erro" });
}
public dynamic Post(Medico medico)
{
var result = MedicoBL.Inserir(medico);
if (result)
{
return(new { Status = "S", Message = "Sucesso" });
}
return(new { Status = "E", Message = "Erro" });
}
public ActionResult Editar(int id)
{
var medicoViewModel = MedicoBL.BuscaMedicoViewModelPorId(id);
//Cidades
var allCidades = MedicoBL.BuscaCidades();
//Especialidades
var allEspecialidades = MedicoBL.BuscaEspecialidades();
ViewBag.IDCidade = new SelectList(allCidades, "IDCidade", "Nome", medicoViewModel.IDCidade);
ViewBag.IDEspecialidade = new SelectList(allEspecialidades, "IDEspecialidade", "Nome", medicoViewModel.IDEspecialidade);
return(View(medicoViewModel));
}
public ActionResult Adicionar()
{
//Cidades
var allCidades = MedicoBL.BuscaCidades();
//Especialidades
var allEspecialidades = MedicoBL.BuscaEspecialidades();
//No formulário de cadastro do Médicos,essas informações serão apresentadas em um ComboBox (ou Dropdownlist).No caso de HTML,
//o ComboBox é representado pelo elemento select.
//Nas propriedades dinâmicas da ViewBag retornarmos já o elemento que será apresentado na View. Para isso utilizamos o helper SelectList
ViewBag.IDCidade = new SelectList(allCidades, "IDCidade", "Nome");
ViewBag.IDEspecialidade = new SelectList(allEspecialidades, "IDEspecialidade", "Nome");
return(View());
}
public ActionResult Editar(MedicoViewModel medicoViewModel)
{
if (ModelState.IsValid)
{
MedicoBL.AtualizaMedico(medicoViewModel);
return(RedirectToAction("Index"));
}
//Cidades
var allCidades = MedicoBL.BuscaCidades();
//Especialidades
var allEspecialidades = MedicoBL.BuscaEspecialidades();
ViewBag.IDCidade = new SelectList(allCidades, "IDCidade", "Nome", medicoViewModel.IDCidade);
ViewBag.IDEspecialidade = new SelectList(allEspecialidades, "IDEspecialidade", "Nome", medicoViewModel.IDEspecialidade);
return(View(medicoViewModel));
}
public static async Task <string> EliminarMedico()
{
if (await ValidarMedico() == null)
{
return("Validacion de usuario incorrecta");
}
var bl = new MedicoBL();
Console.WriteLine("Ingrese CMP de medico a eliminar:");
string cmp = Console.ReadLine();
if (!await ValidarCMP(cmp))
{
return("CMP de medico incorrecto o inexistente");
}
await bl.EliminarMedicoAsync(cmp);
return("Medico eliminado exitosamente");
}
public static async Task <string> InsertarMedico()
{
if (await ValidarMedico() == null)
{
return("Validacion de usuario incorrecta");
}
MedicoBL bl = new MedicoBL();
var medico = new Medico();
Console.WriteLine("Ingrese CMP");
string CMP = Console.ReadLine();
await MostrarEspecialidades();
Console.WriteLine("Ingrese CodEspecialidad");
string CodEspecialidad = Console.ReadLine();
if (!await ValidarEspecialidad(CodEspecialidad))
{
return("Ingrese especialidad correcta");
}
if (await ValidarCMP(CMP) && await ValidarEspecialidad(CodEspecialidad))
{
return("Medico en esa especialidad ya asignado");
}
medico.CMP = CMP;
medico.CodEspecialidad = CodEspecialidad;
Console.WriteLine("Ingrese Dni");
medico.Dni = Console.ReadLine();
Console.WriteLine("Ingrese Nombre");
medico.Nombre = Console.ReadLine();
Console.WriteLine("Ingrese Apellido");
medico.Apellido = Console.ReadLine();
if (await bl.InsertMedicoAsync(medico) != 0)
{
return("Creacion de medico exitosa");
}
else
{
return("Creacion de medico fallida");
}
}
public ActionResult Adicionar()
{
//Cidades
var allCidades = MedicoBL.BuscaCidades();
//Especialidades
var allEspecialidades = MedicoBL.BuscaEspecialidades();
//No formulário de cadastro do Médicos,essas informações serão apresentadas em um ComboBox (ou Dropdownlist).No caso de HTML,
//o ComboBox é representado pelo elemento select.
//Nas propriedades dinâmicas da ViewBag retornarmos já o elemento que será apresentado na View. Para isso utilizamos o helper SelectList
//Esta ViewBag recebe uma estrutura DropDownList que é criada através da classe SelectList e os parâmetros utilizados são:
//Source, Value, Name (Origem do dado [Método ListarClientes], valor do elemento e nome a ser exibido).
//Estes parâmetros precisam coincidir com as propriedades da estrutura do seu dado (classe Cliente).
//Para o Razor HtmlHelper criar corretamente seu DropDownList basta informar (no formato String) o
//nome da ViewBag que contém a estrutura de dados, foi adicionado um segundo parâmetro para criar um elemento em
//branco na primeira posição, assim evitando que o primeiro item seja selecionado por engano.
ViewBag.IDCidade = new SelectList(allCidades, "IDCidade", "Nome");
ViewBag.IDEspecialidade = new SelectList(allEspecialidades, "IDEspecialidade", "Nome");
return(View());
}
public IEnumerable <Medico> Get()
{
return(MedicoBL.BuscaMedicos());
}
public Medico Get(int id)
{
return(MedicoBL.BuscaPorId(id));
}
static async Task MainAsync()
{
// INICIO DE PROGRAMA
// INSTANCIAMOS CLASES DE LA CAPA DE ENTIDADES
// INSTANCIAMOS CLASES DE LA CAPA DE NEGOCIOS
HistoriaClinicaBL Historias = new HistoriaClinicaBL();
//EspecialidadBL especialidades = new EspecialidadBL();
PacienteBL Pacientes = new PacienteBL();
MedicoBL Medicos = new MedicoBL();
string mensaje = "";
await MenuPrincipal();
// MENU
async Task MenuPrincipal()
{
Console.Clear();
int selMain = 0;
string menu = @"MENU PRINCIPAL:
1. Administracion de citas.
2. Administracion de pacientes.
3. Administracion de historias clinicas.
4. Administracion de especialidades.
5. Administracion de personal medico.
6. Administracion de medicamentos de farmacia.
7. Administracion de enfermedades.
8. Administracion de diagnosticos.
Ingrese numero para elegir opcion:
";
Console.WriteLine(menu);
selMain = int.Parse(Console.ReadLine());
if (selMain == 1)
{
await GestionCitas();
}
if (selMain == 2)
{
await GestionPacientes();
}
if (selMain == 3)
{
await GestionHistoriasClinicas();
}
if (selMain == 4)
{
await GestionEspecialidades();
}
if (selMain == 5)
{
await GestionPersonalMedico();
}
if (selMain == 6)
{
await GestionMedicamentos();
}
if (selMain == 7)
{
await GestionEnfermedades();
}
if (selMain == 8)
{
await GestionDiagnosticos();
}
}
// Admision y generacion de cita
async Task GestionCitas()
{
var citas = await Metodos.GetCitas();
Console.Clear();
mensaje = "";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE CITAS");
await Metodos.MostrarCitas();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE PACIENTES");
await Metodos.MostrarPacientes();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE HISTORIAS CLINICAS");
await Metodos.MostrarHistorias();
string MenuAdmision = @"MENU CITAS:
1. Generar cita.
2. Eliminar cita.
3. Generar interconsulta.
4. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuAdmision);
int selMainAdm = int.Parse(Console.ReadLine());
if (selMainAdm == 1)
{
await GenerarCita(); await GestionCitas();
}
if (selMainAdm == 2)
{
await Metodos.EliminarCita(); await GestionCitas();
}
//if (selMainAdm == 3) { await GenerarInterconsulta(); await GestionCitas(); }
if (selMainAdm == 4)
{
await MenuPrincipal(); mensaje = "";
}
}
// Generar cita y codigo de cita
async Task GenerarCita()
{
var pacientes = await Metodos.GetPacientes();
var historias = await Metodos.GetHistoriasClinicas();
var citas = await Metodos.GetCitas();
var especialidades = await Metodos.GetEspecialidades();
var medicos = await Metodos.GetMedicos();
string cita = "";
Console.Clear();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE PACIENTES");
await Metodos.MostrarPacientes();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE HISTORIAS CLINICAS");
await Metodos.MostrarHistorias();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE CITAS");
await Metodos.MostrarCitas();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE ESPECIALIDADES");
await Metodos.MostrarEspecialidades();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE MEDICOS");
await Metodos.MostrarMedicos();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE DIAGNOSTICOS");
await Metodos.MostrarDiagnosticos();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
cita = await Metodos.GenerarCita();
if (cita.Split(":")[0] != "Error")
{
mensaje = cita;
//string Dni = cita.Split(":")[1];
await GestionDiagnosticos();
}
mensaje = cita;
}
async Task GestionPacientes()
{
List <Paciente> pacientes = await Metodos.GetPacientes();
Console.Clear();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE PACIENTES");
await Metodos.MostrarPacientes();
string MenuEspecialidades = @"MENU ESPECIALIDADES:
1. Crear paciente.
2. Actualizar paciente.
3. Eliminar paciente.
4. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuEspecialidades);
int selMainPac = int.Parse(Console.ReadLine());
if (selMainPac == 1)
{
mensaje = await Metodos.InsertarPaciente(); await GestionPacientes();
}
if (selMainPac == 2)
{
mensaje = await Metodos.ActualizarPaciente(); await GestionPacientes();
}
if (selMainPac == 3)
{
mensaje = await Metodos.EliminarPaciente(); await GestionPacientes();
}
//if (selMainPac == 4) { mensaje = await Metodos.EliminarPacientesTodos(); await GestionPacientes(); }
if (selMainPac == 4)
{
await MenuPrincipal(); mensaje = "";
}
}
//Gestion Historias Clinicas
async Task GestionHistoriasClinicas()
{
Console.Clear();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE HISTORIAS CLINICAS");
await Metodos.MostrarHistorias();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE PACIENTES");
await Metodos.MostrarPacientes();
string MenuEspecialidades = @"MENU HISTORIAS CLINICAS:
1. Crear historia clinica.
2. Actualizar historia clinica.
3. Eliminar historia clinica.
4. Volver a menu principal
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuEspecialidades);
int selMainPac = int.Parse(Console.ReadLine());
if (selMainPac == 1)
{
mensaje = await Metodos.InsertarHistoriaClinica(); await GestionHistoriasClinicas();
}
if (selMainPac == 2)
{
mensaje = await Metodos.UpdateHistoriaClinica(); await GestionHistoriasClinicas();
}
if (selMainPac == 3)
{
mensaje = await Metodos.EliminarHistoriaClinica(); await GestionHistoriasClinicas();
}
if (selMainPac == 4)
{
await MenuPrincipal(); mensaje = "";
}
}
// Gestion de especialidades
async Task GestionEspecialidades()
{
List <Especialidad> especialidades = await Metodos.GetEspecialidades();
Console.Clear();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE ESPECIALIDADES");
await Metodos.MostrarEspecialidades();
string MenuEspecialidades = @"MENU ESPECIALIDADES:
1. Generar especialidad.
2. Actualizar especialidad.
3. Eliminar especialidad.
4. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuEspecialidades);
int selMainEsp = int.Parse(Console.ReadLine());
if (selMainEsp == 1)
{
mensaje = await Metodos.InsertarEspecialidad(); await GestionEspecialidades();
}
if (selMainEsp == 2)
{
mensaje = await Metodos.UpdateEspecialidad(); await GestionEspecialidades();
}
if (selMainEsp == 3)
{
mensaje = await Metodos.DeleteEspecialidad(); await GestionEspecialidades();
}
if (selMainEsp == 4)
{
await MenuPrincipal(); mensaje = "";
}
}
async Task GestionPersonalMedico()
{
var medicos = await Metodos.GetMedicos();
Console.Clear();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE MEDICOS");
await Metodos.MostrarMedicos();
string MenuEspecialidades = @"MENU MEDICOS:
1. Crear Medico.
2. Actualizar Medico.
3. Eliminar Medico.
4. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuEspecialidades);
int selMainMed = int.Parse(Console.ReadLine());
if (selMainMed == 1)
{
mensaje = await Metodos.InsertarMedico(); await GestionPersonalMedico();
}
if (selMainMed == 2)
{
mensaje = await Metodos.ActualizarMedico(); await GestionPersonalMedico();
}
if (selMainMed == 3)
{
mensaje = await Metodos.EliminarMedico(); await GestionPersonalMedico();
}
if (selMainMed == 4)
{
await MenuPrincipal(); mensaje = "";
}
}
// Diagnostico y receta de medicamentos
async Task GestionMedicamentos()
{
//Console.Clear();
mensaje = "";
string MenuMedicamentos = @"MENU MEDICAMENTOS:
1. Insertar Medicamento.
2. Actualizar Medicamento.
3. Eliminar Medicamento.
4. Mostrar Medicamentos.
5. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuMedicamentos);
int selMainMed = int.Parse(Console.ReadLine());
if (selMainMed == 1)
{
mensaje = await Metodos.InsertarMedicamento(); await GestionMedicamentos();
}
if (selMainMed == 2)
{
mensaje = await Metodos.UpdateMedicamento(); await GestionMedicamentos();
}
if (selMainMed == 3)
{
mensaje = await Metodos.EliminarMedicamento(); await GestionMedicamentos();
}
if (selMainMed == 4)
{
await Metodos.MostrarMedicamentos(); await GestionMedicamentos();
}
if (selMainMed == 5)
{
await MenuPrincipal(); mensaje = "";
}
}
// Diagnostico y receta de enfermedades
async Task GestionEnfermedades()
{
Console.Clear();
string MenuEnfermedades = @"SISTEMA HOSPITALARIO:
1. Registrar Enfermedad.
2. Actualizar Enfermedad.
3. Eliminar Enfermedad.
4. Mostrar Enfermedad.
5. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuEnfermedades);
int selMainEnf = int.Parse(Console.ReadLine());
if (selMainEnf == 1)
{
mensaje = await Metodos.InsertarEnfermedad(); await GestionEnfermedades();
}
if (selMainEnf == 2)
{
mensaje = await Metodos.ActualizarEnfermedad(); await GestionEnfermedades();
}
if (selMainEnf == 3)
{
mensaje = await Metodos.EliminarEnfermedad(); await GestionEnfermedades();
}
if (selMainEnf == 4)
{
await Metodos.MostrarEnfermedades(); await GestionEnfermedades();
}
if (selMainEnf == 5)
{
await MenuPrincipal(); mensaje = "";
}
}
// Gestion de diagnosticos
async Task GestionDiagnosticos()
{
Console.Clear();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE DIAGNOSTICOS");
await Metodos.MostrarDiagnosticos();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("LISTA DE CITAS");
await Metodos.MostrarCitas();
string MenuDiagnosticos = @"MENU DIAGNOSTICOS:
1. Registrar Diagnostico.
2. Actualizar Diagnostico.
3. Eliminar Diagnostico.
4. Mostrar Diagnosticos.
5. Volver a menu principal.
";
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(mensaje);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(MenuDiagnosticos);
int selMainDiag = int.Parse(Console.ReadLine());
if (selMainDiag == 1)
{
mensaje = await Metodos.InsertarDiagnostico(); await GestionDiagnosticos();
}
if (selMainDiag == 2)
{
mensaje = await Metodos.UpdateDiagnostico(); await GestionDiagnosticos();
}
if (selMainDiag == 3)
{
mensaje = await Metodos.DeleteDiagnostico(); await GestionDiagnosticos();
}
if (selMainDiag == 4)
{
mensaje = await Metodos.MostrarDiagnosticos(); await GestionDiagnosticos();
}
if (selMainDiag == 5)
{
await MenuPrincipal(); mensaje = "";
}
}
}
public static async Task <string> ActualizarMedico()
{
var medico = await ValidarMedico();
if (medico == null)
{
return("Medico no registrado");
}
var bl = new MedicoBL();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine(medico);
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("¿Qué desea modificar?");
string opcionesPac = @"
0) CMP
1) CodEspecialidad.
2) Nombre.
3) Apellido.
4) Dni.
5) Ninguno.";
Console.WriteLine(opcionesPac);
int opciones = int.Parse(Console.ReadLine());
switch (opciones)
{
case 0:
Console.WriteLine("Ingrese nuevo CMP:");
string cmp = Console.ReadLine();
if (await ValidarCMP(cmp))
{
return("CMP ya esta en uso");
}
medico.CMP = cmp;
break;
case 1:
await MostrarEspecialidades();
Console.WriteLine("Ingrese nuevo CodEspecialidad: ");
string CodEspecialidad = Console.ReadLine();
if (!await ValidarEspecialidad(CodEspecialidad))
{
return("Especialidad incorrecta");
}
medico.CodEspecialidad = CodEspecialidad;
break;
case 2:
Console.WriteLine("Ingrese nuevo Nombre: ");
medico.Nombre = Console.ReadLine();
break;
case 3:
Console.WriteLine("Ingrese nuevo Apellido: ");
medico.Apellido = Console.ReadLine();
break;
case 4:
Console.WriteLine("Ingrese nuevo Dni:");
string Dni = Console.ReadLine();
if (!await ValidarLongitudDni(Dni))
{
return("Numero de digitos no validos para Dni");
}
medico.Dni = Console.ReadLine();
break;
case 5:
return("No se hicieron cambios");
default:
return("Ingrese una opcion correcta");
}
if (await bl.ActualizarMedicoAsync(medico) != 0)
{
return("Medico actualizado exitosamente");
}
else
{
return("Proceso fallido");
}
}
public ActionResult Index()
{
var medicos = MedicoBL.BuscaMedicos();
return(View(medicos));
}
public ActionResult Buscar(string crm)
{
var medicos = MedicoBL.BuscaMedicos();
return(View("Index", medicos.Where(x => x.CRM.Equals(crm))));
}
// METODOS DE ADMINISTRACION DE MEDICOS
public static async Task <List <Medico> > GetMedicos()
{
MedicoBL bl = new MedicoBL();
return(await bl.GetMedicosAsync());
}