Пример #1
0
        public RespuestaBD Agregar(NuevoArchivo nuevoArchivo)
        {
            using (InoBD db = new InoBD())
            {
                Dominio.Entidades.Archivo archivo           = Mapper.Map <Dominio.Entidades.Archivo>(nuevoArchivo);
                Dominio.Entidades.Archivo archivoEncontrado = db.Archivos.Where(x => x.IdEspecialidad == nuevoArchivo.IdEspecialidad && x.IdServicio == nuevoArchivo.IdServicio && x.HistoriaClinica == nuevoArchivo.HistoriaClinica && x.NombreArchivo == nuevoArchivo.NombreArchivo).FirstOrDefault();
                if (archivoEncontrado == null)
                {
                    db.Archivos.Add(archivo);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = archivo.IdArchivo;
                    respuesta.Mensaje = "Se subió el archivo correctamente.";
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 1;
                    respuesta.Mensaje = "Se subió el archivo correctamente.";
                }

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "Archivo",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(nuevoArchivo),
                    IdUsuario       = nuevoArchivo.IdUsuarioCreacion
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(respuesta);
            }
        }
Пример #2
0
        public string Eliminar(int Id, int IdUsuario)
        {
            using (InoBD db = new InoBD())
            {
                string rutaCompleta = "";
                Dominio.Entidades.Archivo archivo = db.Archivos.Find(Id);
                string valoresAntiguos            = JsonConvert.SerializeObject(archivo);
                if (archivo != null)
                {
                    db.Archivos.Remove(archivo);
                    rutaCompleta = archivo.RutaCompleta;
                    db.SaveChanges();
                }
                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Eliminar",
                    NombreTabla     = "Archivo",
                    ValoresAntiguos = valoresAntiguos,
                    ValoresNuevos   = null,
                    IdUsuario       = IdUsuario
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(rutaCompleta);
            }
        }
Пример #3
0
        public int ConsultaExternaAdicionalesPorMedicoRegistrar(NuevaAdicional nuevaAdicional)
        {
            using (GalenPlusBD db = new GalenPlusBD())
            {
                int adicional = db.Database.SqlQuery <int>("dbo.INO_ConsultaExternaAdicionalesPorMedicoRegistrar @Hc,@Paciente,@IdEspecialidad,@IdServicio,@IdMedico,@FechaAdicional,@FechaRegistro,@IdUsuario",
                                                           new SqlParameter("Hc", nuevaAdicional.Hc),
                                                           new SqlParameter("Paciente", nuevaAdicional.Paciente),
                                                           new SqlParameter("IdEspecialidad", nuevaAdicional.IdEspecialidad),
                                                           new SqlParameter("IdServicio", nuevaAdicional.IdServicio),
                                                           new SqlParameter("IdMedico", nuevaAdicional.IdMedico),
                                                           new SqlParameter("FechaAdicional", nuevaAdicional.FechaAdicional),
                                                           new SqlParameter("FechaRegistro", nuevaAdicional.FechaRegistro),
                                                           new SqlParameter("IdUsuario", nuevaAdicional.IdUsuario)).FirstOrDefault();

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "CitaAdicional",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(nuevaAdicional),
                    IdUsuario       = nuevaAdicional.IdUsuario
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(adicional);
            }
        }
Пример #4
0
        public RespuestaBD EventoAsistenciaRegistrar(NuevaAsistencia nuevaAsistencia)
        {
            using (GalenPlusBD db = new GalenPlusBD())
            {
                int IdRegistro = db.Database.SqlQuery <int>("dbo.INO_EventoAsistenciaRegistrar @IdEvento, @IdParticipante, @IdHorario, @FechaRegistro, @IdUsuario",
                                                            new SqlParameter("IdEvento", nuevaAsistencia.IdEvento),
                                                            new SqlParameter("IdParticipante", nuevaAsistencia.IdParticipante),
                                                            new SqlParameter("IdHorario", nuevaAsistencia.IdHorario),
                                                            new SqlParameter("FechaRegistro", nuevaAsistencia.FechaRegistro),
                                                            new SqlParameter("IdUsuario", nuevaAsistencia.IdUsuario)).FirstOrDefault();

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "EventoAsistencia",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(nuevaAsistencia),
                    IdUsuario       = nuevaAsistencia.IdUsuario
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(new RespuestaBD
                {
                    Id = IdRegistro,
                    Mensaje = IdRegistro > 0 ? "Se guardó correctamente la atención." : "El participante ya ha sido registrado para este horario."
                });
            }
        }
Пример #5
0
        public RespuestaBD Actualizar(ActualizarRol peticionDeActualizacion)
        {
            using (InoBD db = new InoBD())
            {
                Rol    rolEncontrado   = db.Roles.Find(peticionDeActualizacion.IdRol);
                string valoresAntiguos = JsonConvert.SerializeObject(rolEncontrado);
                if (rolEncontrado != null)
                {
                    db.Entry(rolEncontrado).CurrentValues.SetValues(peticionDeActualizacion);
                    db.SaveChanges();
                    respuesta.Id = rolEncontrado.IdRol;
                    //Mensaje de respuesta
                    respuesta.Mensaje = "Se modificó el rol correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Actualizar",
                        NombreTabla     = "Rol",
                        ValoresAntiguos = valoresAntiguos,
                        ValoresNuevos   = JsonConvert.SerializeObject(peticionDeActualizacion),
                        IdUsuario       = peticionDeActualizacion.IdUsuarioModificacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El rol que desea modificar no existe.";
                }

                return(respuesta);
            }
        }
Пример #6
0
        public RespuestaBD Crear(NuevoRol peticionDeCreacion)
        {
            using (InoBD db = new InoBD())
            {
                Rol rol           = Mapper.Map <Rol>(peticionDeCreacion);
                Rol rolEncontrado = db.Roles.Where(x => x.Nombre == peticionDeCreacion.Nombre).FirstOrDefault();
                if (rolEncontrado == null)
                {
                    db.Roles.Add(rol);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = rol.IdRol;
                    respuesta.Mensaje = "Se creó el rol correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "Rol",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(peticionDeCreacion),
                        IdUsuario       = peticionDeCreacion.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El rol que desea crear ya existe.";
                }

                return(respuesta);
            }
        }
Пример #7
0
        public RespuestaBD EditarSueroMalReferenciado(ActualizarSueroMalReferenciado actualizarSueroMalReferenciado)
        {
            using (InoBD db = new InoBD())
            {
                SueroMalReferenciado sueroMalReferenciado = db.SueroMalReferenciado.Find(actualizarSueroMalReferenciado.IdSueroMalReferenciado);
                string valoresAntiguos = JsonConvert.SerializeObject(sueroMalReferenciado);
                if (sueroMalReferenciado != null)
                {
                    db.Entry(sueroMalReferenciado).CurrentValues.SetValues(actualizarSueroMalReferenciado);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = sueroMalReferenciado.IdSueroMalReferenciado;
                    respuesta.Mensaje = "Se modificó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Actualizar",
                        NombreTabla     = "SueroMalReferenciado",
                        ValoresAntiguos = valoresAntiguos,
                        ValoresNuevos   = JsonConvert.SerializeObject(actualizarSueroMalReferenciado),
                        IdUsuario       = actualizarSueroMalReferenciado.IdUsuarioModificacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El campo solicitado no existe.";
                }

                return(respuesta);
            }
        }
Пример #8
0
        public RespuestaBD EditarRendimientoHoraTrabajador(ActualizarRendimientoHoraTrabajador actualizarRendimientoHoraTrabajador)
        {
            using (InoBD db = new InoBD())
            {
                RendimientoHoraTrabajador rendimientoHoraTrabajador = db.RendimientoHoraTrabajador.Find(actualizarRendimientoHoraTrabajador.IdRendimientoHoraTrabajador);
                string valoresAntiguos = JsonConvert.SerializeObject(rendimientoHoraTrabajador);
                if (rendimientoHoraTrabajador != null)
                {
                    db.Entry(rendimientoHoraTrabajador).CurrentValues.SetValues(actualizarRendimientoHoraTrabajador);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = rendimientoHoraTrabajador.IdRendimientoHoraTrabajador;
                    respuesta.Mensaje = "Se modificó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Actualizar",
                        NombreTabla     = "RendimientoHoraTrabajador",
                        ValoresAntiguos = valoresAntiguos,
                        ValoresNuevos   = JsonConvert.SerializeObject(actualizarRendimientoHoraTrabajador),
                        IdUsuario       = actualizarRendimientoHoraTrabajador.IdUsuarioModificacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El campo solicitado no existe.";
                }

                return(respuesta);
            }
        }
Пример #9
0
        public RespuestaBD ActualizarNroHistoriaClinicaTemporal(ActualizarHistoriaClinicaTemporal actualizarHistoriaClinicaTemporal)
        {
            using (GalenPlusBD db = new GalenPlusBD())
            {
                int HistoricaClinica = db.Database.SqlQuery <int>("dbo.INO_ActualizarNroHistoriaClinicaTemporal @AntiguoHC,@Hc,@IdUsuario,@IdTipoNumeracion,@IdPaciente,@IdManual",
                                                                  new SqlParameter("AntiguoHC", actualizarHistoriaClinicaTemporal.AntiguaHistoriaClinica),
                                                                  new SqlParameter("Hc", actualizarHistoriaClinicaTemporal.HistoriaClinica),
                                                                  new SqlParameter("IdUsuario", actualizarHistoriaClinicaTemporal.IdUsuario),
                                                                  new SqlParameter("IdTipoNumeracion", actualizarHistoriaClinicaTemporal.IdTipoNumeracion),
                                                                  new SqlParameter("IdPaciente", actualizarHistoriaClinicaTemporal.IdPaciente),
                                                                  new SqlParameter("IdManual", actualizarHistoriaClinicaTemporal.IdManual)).FirstOrDefault();

                //Mensaje de respuesta
                respuesta.Id      = HistoricaClinica;
                respuesta.Mensaje = "Se ingresó los datos correctamente.";

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Actualizar",
                    NombreTabla     = "PacientesTemporal",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(actualizarHistoriaClinicaTemporal),
                    IdUsuario       = actualizarHistoriaClinicaTemporal.IdUsuario
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(respuesta);
            }
        }
Пример #10
0
        public RespuestaBD AgregarRendimientoHoraTrabajador(NuevoRendimientoHoraTrabajador nuevoRendimientoHoraTrabajador)
        {
            using (InoBD db = new InoBD())
            {
                RendimientoHoraTrabajador rendimientoHoraTrabajador = Mapper.Map <RendimientoHoraTrabajador>(nuevoRendimientoHoraTrabajador);
                db.RendimientoHoraTrabajador.Add(rendimientoHoraTrabajador);
                db.SaveChanges();

                //Mensaje de respuesta
                respuesta.Id      = rendimientoHoraTrabajador.IdRendimientoHoraTrabajador;
                respuesta.Mensaje = "Se ingresó los datos correctamente.";

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "RendimientoHoraTrabajador",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(nuevoRendimientoHoraTrabajador),
                    IdUsuario       = nuevoRendimientoHoraTrabajador.IdUsuarioCreacion
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(respuesta);
            }
        }
Пример #11
0
        public RespuestaBD AgregarEquipoMalCalibrado(NuevoEquipoMalCalibrado nuevoEquipoMalCalibrado)
        {
            using (InoBD db = new InoBD())
            {
                EquipoMalCalibrado equipoMalCalibrado = Mapper.Map <EquipoMalCalibrado>(nuevoEquipoMalCalibrado);
                db.EquipoMalCalibrado.Add(equipoMalCalibrado);
                db.SaveChanges();

                //Mensaje de respuesta
                respuesta.Id      = equipoMalCalibrado.IdEquipoMalCalibrado;
                respuesta.Mensaje = "Se ingresó los datos correctamente.";

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "EquipoMalCalibrado",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(nuevoEquipoMalCalibrado),
                    IdUsuario       = nuevoEquipoMalCalibrado.IdUsuarioCreacion
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(respuesta);
            }
        }
Пример #12
0
        public RespuestaBD Crear(NuevaAplicacion peticionDeCreacion)
        {
            using (InoBD db = new InoBD())
            {
                Dominio.Entidades.Aplicacion aplicacion           = Mapper.Map <Dominio.Entidades.Aplicacion>(peticionDeCreacion);
                Dominio.Entidades.Aplicacion aplicacionEncontrada = db.Aplicaciones.Where(x => x.Nombre == peticionDeCreacion.Nombre).FirstOrDefault();
                if (aplicacionEncontrada == null)
                {
                    db.Aplicaciones.Add(aplicacion);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = aplicacion.IdAplicacion;
                    respuesta.Mensaje = "Se creó la aplicación correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "Aplicacion",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(peticionDeCreacion),
                        IdUsuario       = peticionDeCreacion.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El nombre de la aplicación ya existe.";
                }

                return(respuesta);
            }
        }
Пример #13
0
        public RespuestaBD Crear(NuevoModulo peticionDeCreacion)
        {
            using (InoBD db = new InoBD())
            {
                Dominio.Entidades.Modulo modulo           = Mapper.Map <Dominio.Entidades.Modulo>(peticionDeCreacion);
                Dominio.Entidades.Modulo moduloEncontrado = db.Modulo.Where(x => x.Nombre == peticionDeCreacion.Nombre).FirstOrDefault();
                if (moduloEncontrado == null)
                {
                    db.Modulo.Add(modulo);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = modulo.IdModulo;
                    respuesta.Mensaje = "Se creó el módulo correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "Modulo",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(peticionDeCreacion),
                        IdUsuario       = peticionDeCreacion.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El nombre del módulo ya existe.";
                }

                return(respuesta);
            }
        }
Пример #14
0
        public RespuestaBD EditarPocoFrecuente(ActualizarPocoFrecuente actualizarPocoFrecuente)
        {
            using (InoBD db = new InoBD())
            {
                PocoFrecuente pocoFrecuente   = db.PocoFrecuente.Find(actualizarPocoFrecuente.IdPocoFrecuente);
                string        valoresAntiguos = JsonConvert.SerializeObject(pocoFrecuente);
                if (pocoFrecuente != null)
                {
                    db.Entry(pocoFrecuente).CurrentValues.SetValues(actualizarPocoFrecuente);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = pocoFrecuente.IdPocoFrecuente;
                    respuesta.Mensaje = "Se modificó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Actualizar",
                        NombreTabla     = "PocoFrecuente",
                        ValoresAntiguos = valoresAntiguos,
                        ValoresNuevos   = JsonConvert.SerializeObject(actualizarPocoFrecuente),
                        IdUsuario       = actualizarPocoFrecuente.IdUsuarioModificacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El campo solicitado no existe.";
                }

                return(respuesta);
            }
        }
Пример #15
0
        public RespuestaBD AgregarCalibracionDeficiente(NuevoCalibracionDeficiente nuevoCalibracionDeficiente)
        {
            using (InoBD db = new InoBD())
            {
                CalibracionDeficiente calibracionDeficiente = Mapper.Map <CalibracionDeficiente>(nuevoCalibracionDeficiente);
                db.CalibracionDeficiente.Add(calibracionDeficiente);
                db.SaveChanges();

                //Mensaje de respuesta
                respuesta.Id      = calibracionDeficiente.IdCalibracionDeficiente;
                respuesta.Mensaje = "Se ingresó los datos correctamente.";

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "CalibracionDeficiente",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(nuevoCalibracionDeficiente),
                    IdUsuario       = nuevoCalibracionDeficiente.IdUsuarioCreacion
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(respuesta);
            }
        }
Пример #16
0
 public void AgregarAuditoria(AuditoriaGeneral auditoriaGeneral)
 {
     using (InoBD db = new InoBD())
     {
         Dominio.Entidades.Auditoria auditoria = Mapper.Map <Dominio.Entidades.Auditoria>(auditoriaGeneral);
         auditoria.IpLogueo = db.Empleados.Where(x => x.IdEmpleado == auditoriaGeneral.IdUsuario).FirstOrDefault().LoginIp;
         db.Auditoria.Add(auditoria);
         db.SaveChanges();
     }
 }
Пример #17
0
        public RespuestaBD CambioClave(UsuarioCambioClave usuarioCambioClave)
        {
            using (InoBD db = new InoBD())
            {
                usuarioCambioClave.ClaveAntigua = Security.HashSHA1(usuarioCambioClave.ClaveAntigua);
                Empleado empleado     = db.Empleados.Where(x => x.Usuario == usuarioCambioClave.Usuario && x.Contrasena == usuarioCambioClave.ClaveAntigua).FirstOrDefault();
                int      UsuarioAdmin = Convert.ToInt32(ConfigurationManager.AppSettings["UsuarioAdmin"]);
                if (empleado != null && usuarioCambioClave.IdUsuarioModificacion == UsuarioAdmin)
                {
                    empleado = db.Empleados.Where(x => x.Usuario == usuarioCambioClave.Usuario).FirstOrDefault();
                }
                if (empleado != null)
                {
                    if (usuarioCambioClave.ClaveNueva == usuarioCambioClave.ClaveNuevaRepetida)
                    {
                        empleado.Contrasena            = Security.HashSHA1(usuarioCambioClave.ClaveNueva);
                        empleado.IdUsuarioModificacion = usuarioCambioClave.IdUsuarioModificacion;
                        empleado.FechaModificacion     = DateTime.Now;
                        db.SaveChanges();
                        //Mensaje de respuesta
                        respuesta.Id      = empleado.IdEmpleado;
                        respuesta.Mensaje = "La contraseña se cambió correctamente.";

                        // Auditoria
                        AuditoriaGeneral auditoria = new AuditoriaGeneral
                        {
                            Accion          = "CambioDeClave",
                            NombreTabla     = "Empleado",
                            ValoresAntiguos = null,
                            ValoresNuevos   = JsonConvert.SerializeObject(usuarioCambioClave),
                            IdUsuario       = usuarioCambioClave.IdUsuarioModificacion
                        };

                        this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                    }
                    else
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "Las contraseñas nuevas son diferentes, intente nuevamente.";
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "La contraseña ingresada no es correcta, intente nuevamente.";
                }

                return(respuesta);
            }
        }
Пример #18
0
        public RespuestaBD RegistrarAtencionTrabajador(NuevaAtencionTrabajador nuevaAtencionTrabajador)
        {
            using (InoBD db = new InoBD())
            {
                AtencionTrabajador pacienteEncontrado = db.AtencionTrabajador.Where(x => x.FechaCreacion.Day == DateTime.Now.Day &&
                                                                                    x.FechaCreacion.Month == DateTime.Now.Month &&
                                                                                    x.FechaCreacion.Year == DateTime.Now.Year &&
                                                                                    x.HistoriaClinica == nuevaAtencionTrabajador.HistoriaClinica).FirstOrDefault();
                if (pacienteEncontrado == null)
                {
                    AtencionTrabajador atencionTrabajador = Mapper.Map <AtencionTrabajador>(nuevaAtencionTrabajador);
                    db.AtencionTrabajador.Add(atencionTrabajador);
                    db.SaveChanges();

                    foreach (var diagnostico in nuevaAtencionTrabajador.Diagnosticos)
                    {
                        AtencionTrabajador_Diagnostico atencion_Diagnostico = new AtencionTrabajador_Diagnostico
                        {
                            IdAtencionTrabajador = atencionTrabajador.IdAtencionTrabajador,
                            IdDiagnostico        = diagnostico.Id,
                            TipoDiagnostico      = diagnostico.Codigo,
                            IdUsuarioCreacion    = nuevaAtencionTrabajador.IdUsuarioCreacion
                        };
                        db.AtencionTrabajador_Diagnostico.Add(atencion_Diagnostico);
                        db.SaveChanges();
                    }

                    //Mensaje de respuesta
                    respuesta.Id      = atencionTrabajador.IdAtencionTrabajador;
                    respuesta.Mensaje = "Se guardó la atención correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "AtencionTrabajador",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(nuevaAtencionTrabajador),
                        IdUsuario       = nuevaAtencionTrabajador.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El paciente ya cuenta con un registro para el día de hoy, intente de nuevo.";
                }
            }
            return(respuesta);
        }
        public RespuestaBD EditarVenopunturasFallidas(ActualizarVenopunturasFallidas actualizarVenopunturasFallidas)
        {
            using (InoBD db = new InoBD())
            {
                VenopunturasFallidas venopunturasFallidas = db.VenopunturasFallidas.Find(actualizarVenopunturasFallidas.IdVenopunturasFallidas);
                string valoresAntiguos = JsonConvert.SerializeObject(venopunturasFallidas);
                if (venopunturasFallidas != null)
                {
                    VenopunturasFallidas pacienteEncontrado = db.VenopunturasFallidas.Where(x => x.HistoriaClinica == actualizarVenopunturasFallidas.HistoriaClinica && x.FechaOcurrencia == actualizarVenopunturasFallidas.FechaOcurrencia && x.IdVenopunturasFallidas != actualizarVenopunturasFallidas.IdVenopunturasFallidas).FirstOrDefault();
                    if (pacienteEncontrado == null)
                    {
                        db.Entry(venopunturasFallidas).CurrentValues.SetValues(actualizarVenopunturasFallidas);
                        db.SaveChanges();
                        //Mensaje de respuesta
                        respuesta.Id      = venopunturasFallidas.IdVenopunturasFallidas;
                        respuesta.Mensaje = "Se modificó los datos correctamente.";

                        // Auditoria
                        AuditoriaGeneral auditoria = new AuditoriaGeneral
                        {
                            Accion          = "Actualizar",
                            NombreTabla     = "VenopunturasFallidas",
                            ValoresAntiguos = valoresAntiguos,
                            ValoresNuevos   = JsonConvert.SerializeObject(actualizarVenopunturasFallidas),
                            IdUsuario       = actualizarVenopunturasFallidas.IdUsuarioModificacion
                        };
                        this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                    }
                    else
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "El paciente ya se encuentra registrado para esta fecha.";
                        return(respuesta);
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El campo solicitado no existe.";
                }

                return(respuesta);
            }
        }
Пример #20
0
        public RespuestaBD EditarMuestraHemolizadaLipemica(ActualizarMuestraHemolizadaLipemica actualizarMuestraHemolizadaLipemica)
        {
            using (InoBD db = new InoBD())
            {
                MuestraHemolizadaLipemica muestraHemolizadaLipemica = db.MuestraHemolizadaLipemica.Find(actualizarMuestraHemolizadaLipemica.IdMuestraHemolizadaLipemica);
                string valoresAntiguos = JsonConvert.SerializeObject(muestraHemolizadaLipemica);
                if (muestraHemolizadaLipemica != null)
                {
                    MuestraHemolizadaLipemica pacienteEncontrado = db.MuestraHemolizadaLipemica.Where(x => x.HistoriaClinica == actualizarMuestraHemolizadaLipemica.HistoriaClinica && x.NumeroMes == actualizarMuestraHemolizadaLipemica.NumeroMes && x.IdMuestraHemolizadaLipemica != actualizarMuestraHemolizadaLipemica.IdMuestraHemolizadaLipemica).FirstOrDefault();
                    if (pacienteEncontrado == null)
                    {
                        db.Entry(muestraHemolizadaLipemica).CurrentValues.SetValues(actualizarMuestraHemolizadaLipemica);
                        db.SaveChanges();
                        //Mensaje de respuesta
                        respuesta.Id      = muestraHemolizadaLipemica.IdMuestraHemolizadaLipemica;
                        respuesta.Mensaje = "Se modificó los datos correctamente.";

                        // Auditoria
                        AuditoriaGeneral auditoria = new AuditoriaGeneral
                        {
                            Accion          = "Actualizar",
                            NombreTabla     = "MuestraHemolizadaLipemica",
                            ValoresAntiguos = valoresAntiguos,
                            ValoresNuevos   = JsonConvert.SerializeObject(actualizarMuestraHemolizadaLipemica),
                            IdUsuario       = actualizarMuestraHemolizadaLipemica.IdUsuarioModificacion
                        };
                        this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                    }
                    else
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "El paciente ya se encuentra registrado para esta fecha.";
                        return(respuesta);
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El campo solicitado no existe.";
                }

                return(respuesta);
            }
        }
Пример #21
0
        public RespuestaBD Actualizar(ActualizarAplicacion peticionDeActualizacion)
        {
            using (InoBD db = new InoBD())
            {
                Dominio.Entidades.Aplicacion aplicacionEncontrada = db.Aplicaciones.Find(peticionDeActualizacion.IdAplicacion);
                string valoresAntiguos = JsonConvert.SerializeObject(aplicacionEncontrada);
                if (aplicacionEncontrada != null)
                {
                    Dominio.Entidades.Aplicacion nombreEncontrado = db.Aplicaciones.Where(x => x.Nombre == peticionDeActualizacion.Nombre && x.IdAplicacion != peticionDeActualizacion.IdAplicacion).FirstOrDefault();
                    if (nombreEncontrado != null)
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "El nombre de la aplicación ya existe.";
                    }
                    else
                    {
                        db.Entry(aplicacionEncontrada).CurrentValues.SetValues(peticionDeActualizacion);
                        db.SaveChanges();
                        //Mensaje de respuesta
                        respuesta.Id      = aplicacionEncontrada.IdAplicacion;
                        respuesta.Mensaje = "Se modificó la aplicación correctamente.";

                        // Auditoria
                        AuditoriaGeneral auditoria = new AuditoriaGeneral
                        {
                            Accion          = "Actualizar",
                            NombreTabla     = "Aplicacion",
                            ValoresAntiguos = valoresAntiguos,
                            ValoresNuevos   = JsonConvert.SerializeObject(peticionDeActualizacion),
                            IdUsuario       = peticionDeActualizacion.IdUsuarioModificacion
                        };
                        this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "La aplicación no existe.";
                }

                return(respuesta);
            }
        }
Пример #22
0
        public RespuestaBD AsignarRolSubModulo(RolSubModuloDto rolSubModuloDto)
        {
            using (InoBD db = new InoBD())
            {
                //EDITAR
                string valoresAntiguos = "";
                if (rolSubModuloDto.IdRolSubModulo > 0)
                {
                    Dominio.Entidades.RolSubModulo rolSubModulo = db.RolSubModulo.Find(rolSubModuloDto.IdRolSubModulo);
                    valoresAntiguos = JsonConvert.SerializeObject(rolSubModulo);
                    rolSubModulo.IdUsuarioModificacion = rolSubModuloDto.IdUsuarioRegistra;
                    rolSubModulo.FechaModificacion     = DateTime.Now;
                    db.Entry(rolSubModulo).CurrentValues.SetValues(rolSubModuloDto);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = rolSubModulo.IdRolSubModulo;
                    respuesta.Mensaje = "Se asignó el sub módulo al rol correctamente.";
                }
                //AGREGAR
                else
                {
                    Dominio.Entidades.RolSubModulo rolSubModulo = Mapper.Map <Dominio.Entidades.RolSubModulo>(rolSubModuloDto);
                    rolSubModulo.IdUsuarioCreacion = rolSubModuloDto.IdUsuarioRegistra;
                    db.RolSubModulo.Add(rolSubModulo);
                    db.SaveChanges();
                    //Mensaje de respuesta
                    respuesta.Id      = rolSubModulo.IdRolSubModulo;
                    respuesta.Mensaje = "Se asignó el sub módulo al rol correctamente.";
                }

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "AsignarRol",
                    NombreTabla     = "SubModulo",
                    ValoresAntiguos = valoresAntiguos,
                    ValoresNuevos   = JsonConvert.SerializeObject(rolSubModuloDto),
                    IdUsuario       = rolSubModuloDto.IdUsuarioRegistra
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(respuesta);
            }
        }
Пример #23
0
        public RespuestaBD AgregarMuestraHemolizadaLipemica(NuevoMuestraHemolizadaLipemica nuevoMuestraHemolizadaLipemica)
        {
            using (InoBD db = new InoBD())
            {
                MuestraHemolizadaLipemica pacienteEncontrado = db.MuestraHemolizadaLipemica.Where(x => x.HistoriaClinica == nuevoMuestraHemolizadaLipemica.HistoriaClinica && x.NumeroMes == nuevoMuestraHemolizadaLipemica.NumeroMes).FirstOrDefault();
                if (pacienteEncontrado == null)
                {
                    MuestraHemolizadaLipemica muestraHemolizadaLipemica = Mapper.Map <MuestraHemolizadaLipemica>(nuevoMuestraHemolizadaLipemica);
                    db.MuestraHemolizadaLipemica.Add(muestraHemolizadaLipemica);
                    db.SaveChanges();

                    //Mensaje de respuesta
                    respuesta.Id      = muestraHemolizadaLipemica.IdMuestraHemolizadaLipemica;
                    respuesta.Mensaje = "Se ingresó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "MuestraHemolizadaLipemica",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(nuevoMuestraHemolizadaLipemica),
                        IdUsuario       = nuevoMuestraHemolizadaLipemica.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El paciente ya se encuentra registrado para esta fecha.";
                }

                return(respuesta);
            }
        }
        public RespuestaBD AgregarIncumplimientoAnalisis(NuevoIncumplimientoAnalisis nuevoIncumplimientoAnalisis)
        {
            using (InoBD db = new InoBD())
            {
                IncumplimientoAnalisis pacienteEncontrado = db.IncumplimientoAnalisis.Where(x => x.HistoriaClinica == nuevoIncumplimientoAnalisis.HistoriaClinica && x.FechaOcurrencia == nuevoIncumplimientoAnalisis.FechaOcurrencia).FirstOrDefault();
                if (pacienteEncontrado == null)
                {
                    IncumplimientoAnalisis incumplimientoAnalisis = Mapper.Map <IncumplimientoAnalisis>(nuevoIncumplimientoAnalisis);
                    db.IncumplimientoAnalisis.Add(incumplimientoAnalisis);
                    db.SaveChanges();

                    //Mensaje de respuesta
                    respuesta.Id      = incumplimientoAnalisis.IdIncumplimientoAnalisis;
                    respuesta.Mensaje = "Se ingresó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "IncumplimientoAnalisis",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(nuevoIncumplimientoAnalisis),
                        IdUsuario       = nuevoIncumplimientoAnalisis.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El paciente ya se encuentra registrado para esta fecha.";
                }

                return(respuesta);
            }
        }
        public RespuestaBD AgregarTranscripcionErroneaInoportuna(NuevoTranscripcionErroneaInoportuna nuevoTranscripcionErroneaInoportuna)
        {
            using (InoBD db = new InoBD())
            {
                TranscripcionErroneaInoportuna pacienteEncontrado = db.TranscripcionErroneaInoportuna.Where(x => x.HistoriaClinica == nuevoTranscripcionErroneaInoportuna.HistoriaClinica && x.FechaOcurrencia == nuevoTranscripcionErroneaInoportuna.FechaOcurrencia).FirstOrDefault();
                if (pacienteEncontrado == null)
                {
                    TranscripcionErroneaInoportuna transcripcionErroneaInoportuna = Mapper.Map <TranscripcionErroneaInoportuna>(nuevoTranscripcionErroneaInoportuna);
                    db.TranscripcionErroneaInoportuna.Add(transcripcionErroneaInoportuna);
                    db.SaveChanges();

                    //Mensaje de respuesta
                    respuesta.Id      = transcripcionErroneaInoportuna.IdTranscripcionErroneaInoportuna;
                    respuesta.Mensaje = "Se ingresó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "TranscripcionErroneaInoportuna",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(nuevoTranscripcionErroneaInoportuna),
                        IdUsuario       = nuevoTranscripcionErroneaInoportuna.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El paciente ya se encuentra registrado para esta fecha.";
                }

                return(respuesta);
            }
        }
        public RespuestaBD AgregarPacienteSinResultado(NuevoPacienteSinResultado nuevoPacienteSinResultado)
        {
            using (InoBD db = new InoBD())
            {
                PacienteSinResultado pacienteEncontrado = db.PacienteSinResultado.Where(x => x.HistoriaClinica == nuevoPacienteSinResultado.HistoriaClinica && x.FechaOcurrencia == nuevoPacienteSinResultado.FechaOcurrencia).FirstOrDefault();
                if (pacienteEncontrado == null)
                {
                    PacienteSinResultado pacienteSinResultado = Mapper.Map <PacienteSinResultado>(nuevoPacienteSinResultado);
                    db.PacienteSinResultado.Add(pacienteSinResultado);
                    db.SaveChanges();

                    //Mensaje de respuesta
                    respuesta.Id      = pacienteSinResultado.IdPacienteSinResultado;
                    respuesta.Mensaje = "Se ingresó los datos correctamente.";

                    // Auditoria
                    AuditoriaGeneral auditoria = new AuditoriaGeneral
                    {
                        Accion          = "Agregar",
                        NombreTabla     = "PacienteSinResultado",
                        ValoresAntiguos = null,
                        ValoresNuevos   = JsonConvert.SerializeObject(nuevoPacienteSinResultado),
                        IdUsuario       = nuevoPacienteSinResultado.IdUsuarioCreacion
                    };
                    this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El paciente ya se encuentra registrado para esta fecha.";
                }

                return(respuesta);
            }
        }
        public RespuestaBD AgregarOrdenMedica(NuevaOrdenMedica nuevaOrdenMedica)
        {
            using (InoBD db = new InoBD())
            {
                OrdenesMedicas pacienteEncontrado = db.OrdenesMedicas.Where(x => x.Fecha.Day == nuevaOrdenMedica.Fecha.Day &&
                                                                            x.Fecha.Month == nuevaOrdenMedica.Fecha.Month &&
                                                                            x.Fecha.Year == nuevaOrdenMedica.Fecha.Year &&
                                                                            x.IdTipoOrdenMedica == nuevaOrdenMedica.IdTipoOrdenMedica &&
                                                                            x.HistoriaClinica == nuevaOrdenMedica.HistoriaClinica).FirstOrDefault();
                if (pacienteEncontrado == null)
                {
                    if (nuevaOrdenMedica.OrdenesMedicasCodigos.Count > 0)
                    {
                        OrdenesMedicas ordenesMedicas = Mapper.Map <OrdenesMedicas>(nuevaOrdenMedica);
                        ordenesMedicas.OrdenesMedicasCodigos.Clear();
                        db.OrdenesMedicas.Add(ordenesMedicas);
                        db.SaveChanges();

                        foreach (NuevaOrdenesMedicasCodigos nuevaOrdenesMedicasCodigos in nuevaOrdenMedica.OrdenesMedicasCodigos)
                        {
                            OrdenesMedicasCodigos codigoExistente = db.OrdenesMedicasCodigos.Where(x => x.IdOrdenMedica == nuevaOrdenesMedicasCodigos.IdOrdenMedica && x.IdProcedimiento == nuevaOrdenesMedicasCodigos.IdProcedimiento).FirstOrDefault();
                            if (codigoExistente == null)
                            {
                                Procedimiento codigoValido = db.Procedimiento.Where(x => x.IdProcedimiento == nuevaOrdenesMedicasCodigos.IdProcedimiento).FirstOrDefault();
                                if (codigoValido != null)
                                {
                                    OrdenesMedicasCodigos ordenesMedicasCodigos = Mapper.Map <OrdenesMedicasCodigos>(nuevaOrdenesMedicasCodigos);
                                    ordenesMedicasCodigos.IdOrdenMedica     = ordenesMedicas.IdOrdenMedica;
                                    ordenesMedicasCodigos.IdUsuarioCreacion = ordenesMedicas.IdUsuarioCreacion;
                                    ordenesMedicasCodigos.OpcionesOrdenMedica.Clear();
                                    db.OrdenesMedicasCodigos.Add(ordenesMedicasCodigos);

                                    if (nuevaOrdenesMedicasCodigos.OpcionesOrdenMedica.Count > 0)
                                    {
                                        List <int> idOpciones = nuevaOrdenesMedicasCodigos.OpcionesOrdenMedica.Select(r => r.Id).ToList();
                                        List <OpcionesOrdenMedica> opciones = db.OpcionesOrdenMedica.Where(r => idOpciones.Contains(r.IdOpcionOrdenMedica)).ToList();
                                        foreach (OpcionesOrdenMedica opcion in opciones)
                                        {
                                            ordenesMedicasCodigos.OpcionesOrdenMedica.Add(opcion);
                                        }
                                    }
                                    db.SaveChanges();
                                    //Mensaje de respuesta
                                    respuesta.Id      = ordenesMedicas.IdOrdenMedica;
                                    respuesta.Mensaje = "Se creó la información correctamente.";
                                }
                                else
                                {
                                    //Mensaje de respuesta
                                    respuesta.Id      = 0;
                                    respuesta.Mensaje = "El código que desea ingresar no existe.";
                                }
                            }
                        }
                    }
                    if (respuesta.Id > 0)
                    {
                        // Auditoria
                        AuditoriaGeneral auditoria = new AuditoriaGeneral
                        {
                            Accion          = "Agregar",
                            NombreTabla     = string.Concat("OrdenesMedicas|", nuevaOrdenMedica.IdTipoOrdenMedica),
                            ValoresAntiguos = null,
                            ValoresNuevos   = JsonConvert.SerializeObject(nuevaOrdenMedica),
                            IdUsuario       = nuevaOrdenMedica.IdUsuarioCreacion
                        };
                        this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                    }
                    else
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "No se encontró ningún código seleccionado.";
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "El paciente ya cuenta con esta orden médica en la fecha propuesta seleccionada, intente de nuevo.";
                }
            }
            return(respuesta);
        }
Пример #28
0
        public RespuestaBD Crear(NuevoEmpleado peticionDeCreacion)
        {
            using (InoBD db = new InoBD())
            {
                //var idRoles = Array.ConvertAll(peticionDeCreacion.IdRoles.Split(','), int.Parse);
                //List<Rol> roles = db.Roles.Where(x => x.EsActivo == true && idRoles.Contains(x.IdRol)).ToList();
                Empleado empleado = Mapper.Map <Empleado>(peticionDeCreacion);
                if (peticionDeCreacion.Roles.Count > 0)
                {
                    if (peticionDeCreacion.Aplicaciones.Count > 0)
                    {
                        Empleado usuarioEncontrado        = db.Empleados.Where(x => x.Usuario == peticionDeCreacion.Usuario).FirstOrDefault();
                        Empleado correoEncontrado         = db.Empleados.Where(x => x.Correo == peticionDeCreacion.Correo).FirstOrDefault();
                        Empleado documentoEncontrado      = db.Empleados.Where(x => x.NumeroDocumento == peticionDeCreacion.NumeroDocumento).FirstOrDefault();
                        Empleado codigoPlanillaEncontrado = db.Empleados.Where(x => x.CodigoPlanilla == peticionDeCreacion.CodigoPlanilla).FirstOrDefault();
                        if (usuarioEncontrado != null)
                        {
                            //Mensaje de respuesta
                            respuesta.Id      = 0;
                            respuesta.Mensaje = "El nombre de usuario ya existe.";
                        }
                        else if (correoEncontrado != null)
                        {
                            //Mensaje de respuesta
                            respuesta.Id      = 0;
                            respuesta.Mensaje = "El correo del usuario ya existe.";
                        }
                        else if (documentoEncontrado != null)
                        {
                            //Mensaje de respuesta
                            respuesta.Id      = 0;
                            respuesta.Mensaje = "El número de documento del usuario ya existe.";
                        }
                        else if (codigoPlanillaEncontrado != null)
                        {
                            //Mensaje de respuesta
                            respuesta.Id      = 0;
                            respuesta.Mensaje = "El código de planilla del usuario ya existe.";
                        }
                        else
                        {
                            empleado.Contrasena = Security.HashSHA1(peticionDeCreacion.Contrasena);
                            LimpiarObjeto(empleado);
                            db.Empleados.Add(empleado);
                            List <int> idRoles = peticionDeCreacion.Roles.Select(r => r.IdRol).ToList();
                            List <Rol> roles   = db.Roles.Where(r => idRoles.Contains(r.IdRol)).ToList();
                            foreach (Rol rol in roles)
                            {
                                empleado.Roles.Add(rol);
                            }
                            List <int> idAplicaciones = peticionDeCreacion.Aplicaciones.Select(r => r.IdAplicacion).ToList();
                            List <Dominio.Entidades.Aplicacion> aplicaciones = db.Aplicaciones.Where(a => idAplicaciones.Contains(a.IdAplicacion)).ToList();
                            foreach (Dominio.Entidades.Aplicacion aplicacion in aplicaciones)
                            {
                                empleado.Aplicaciones.Add(aplicacion);
                            }
                            db.SaveChanges();
                            //Mensaje de respuesta
                            respuesta.Id      = empleado.IdEmpleado;
                            respuesta.Mensaje = "Se creó el empleado correctamente.";

                            // Auditoria
                            AuditoriaGeneral auditoria = new AuditoriaGeneral
                            {
                                Accion          = "Agregar",
                                NombreTabla     = "Empleado",
                                ValoresAntiguos = null,
                                ValoresNuevos   = JsonConvert.SerializeObject(peticionDeCreacion),
                                IdUsuario       = peticionDeCreacion.IdUsuarioCreacion
                            };
                            this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                        }
                    }
                    else
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "No se ha seleccionado ninguna aplicación, verifique.";
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "No se ha seleccionado ningún rol, verifique.";
                }

                return(respuesta);
            }
        }
Пример #29
0
        public RespuestaBD Actualizar(ActualizarEmpleado peticionDeActualizacion)
        {
            using (InoBD db = new InoBD())
            {
                string valoresAntiguos = "";
                if (peticionDeActualizacion.Roles.Count > 0)
                {
                    if (peticionDeActualizacion.Aplicaciones.Count > 0)
                    {
                        Empleado usuarioEncontrado        = db.Empleados.Find(peticionDeActualizacion.IdEmpleado);
                        Empleado correoEncontrado         = db.Empleados.Where(x => x.Correo == peticionDeActualizacion.Correo && x.IdEmpleado != peticionDeActualizacion.IdEmpleado).FirstOrDefault();
                        Empleado documentoEncontrado      = db.Empleados.Where(x => x.NumeroDocumento == peticionDeActualizacion.NumeroDocumento && x.IdEmpleado != peticionDeActualizacion.IdEmpleado).FirstOrDefault();
                        Empleado codigoPlanillaEncontrado = db.Empleados.Where(x => x.CodigoPlanilla == peticionDeActualizacion.CodigoPlanilla && x.IdEmpleado != peticionDeActualizacion.IdEmpleado).FirstOrDefault();
                        valoresAntiguos = JsonConvert.SerializeObject(usuarioEncontrado);
                        if (usuarioEncontrado != null)
                        {
                            if (correoEncontrado != null)
                            {
                                //Mensaje de respuesta
                                respuesta.Id      = 0;
                                respuesta.Mensaje = "El correo del usuario ya existe.";
                            }
                            else if (documentoEncontrado != null)
                            {
                                //Mensaje de respuesta
                                respuesta.Id      = 0;
                                respuesta.Mensaje = "El número de documento del usuario ya existe.";
                            }
                            else if (codigoPlanillaEncontrado != null)
                            {
                                //Mensaje de respuesta
                                respuesta.Id      = 0;
                                respuesta.Mensaje = "El código de planilla del usuario ya existe.";
                            }
                            else
                            {
                                usuarioEncontrado.IdCondicionTrabajo = peticionDeActualizacion.CondicionTrabajo.Id;
                                usuarioEncontrado.IdTipoEmpleado     = peticionDeActualizacion.TipoEmpleado.Id;
                                usuarioEncontrado.IdTipoDocumento    = peticionDeActualizacion.TipoDocumentoIdentidad.Id;
                                LimpiarObjeto(usuarioEncontrado);
                                db.Entry(usuarioEncontrado).CurrentValues.SetValues(peticionDeActualizacion);
                                List <int> idRoles = peticionDeActualizacion.Roles.Select(r => r.IdRol).ToList();
                                List <Rol> roles   = db.Roles.Where(r => idRoles.Contains(r.IdRol)).ToList();
                                foreach (Rol rol in roles)
                                {
                                    usuarioEncontrado.Roles.Add(rol);
                                }
                                List <int> idAplicaciones = peticionDeActualizacion.Aplicaciones.Select(r => r.IdAplicacion).ToList();
                                List <Dominio.Entidades.Aplicacion> aplicaciones = db.Aplicaciones.Where(a => idAplicaciones.Contains(a.IdAplicacion)).ToList();
                                foreach (Dominio.Entidades.Aplicacion aplicacion in aplicaciones)
                                {
                                    usuarioEncontrado.Aplicaciones.Add(aplicacion);
                                }
                                db.SaveChanges();
                                //Mensaje de respuesta
                                respuesta.Id      = usuarioEncontrado.IdEmpleado;
                                respuesta.Mensaje = "Se modificó el empleado correctamente.";

                                // Auditoria
                                AuditoriaGeneral auditoria = new AuditoriaGeneral
                                {
                                    Accion          = "Actualizar",
                                    NombreTabla     = "Empleado",
                                    ValoresAntiguos = valoresAntiguos,
                                    ValoresNuevos   = JsonConvert.SerializeObject(peticionDeActualizacion),
                                    IdUsuario       = peticionDeActualizacion.IdUsuarioModificacion
                                };
                                this._gestorDeAuditoria.AgregarAuditoria(auditoria);
                            }
                        }
                        else
                        {
                            //Mensaje de respuesta
                            respuesta.Id      = 0;
                            respuesta.Mensaje = "El usuario no existe.";
                        }
                    }
                    else
                    {
                        //Mensaje de respuesta
                        respuesta.Id      = 0;
                        respuesta.Mensaje = "No se ha seleccionado ninguna aplicación, verifique.";
                    }
                }
                else
                {
                    //Mensaje de respuesta
                    respuesta.Id      = 0;
                    respuesta.Mensaje = "No se ha seleccionado ningún rol, verifique.";
                }

                return(respuesta);
            }
        }
Пример #30
0
        public RespuestaBD RegistrarAtencion(RegistroAtencion registroAtencion)
        {
            using (GalenPlusBD db = new GalenPlusBD())
            {
                db.Database.ExecuteSqlCommand("dbo.INO_CEAtencionesRegistrar @IdCita,@NroHistoriaClinica,@Paciente,@IdMedico,@Medico,@IdEspecialidad,@Especialidad,@IdServicio,@Servicio,@Financiamiento," +
                                              "@Diacod1,@Diades1,@IdTipoDiagnostico1,@Diacod2,@Diades2,@IdTipoDiagnostico2,@Diacod3,@Diades3,@IdTipoDiagnostico3,@FechaAtencion,@IdUsuario,@Usuario,@CodProc1,@Coddes1,@CodProc2," +
                                              "@Coddes2,@CodProc3,@Coddes3,@IdResidente,@Residente,@IdTipoCondicionEstablecimiento,@IdTipoCondicionServicio,@Diacod1_OI,@Diades1_OI,@IdTipoDiagnostico1_OI,@Diacod2_OI,@Diades2_OI," +
                                              "@IdTipoDiagnostico2_OI,@Diacod3_OI,@Diades3_OI,@IdTipoDiagnostico3_OI,@CodProc1_OI,@Coddes1_OI,@CodProc2_OI,@Coddes2_OI,@CodProc3_OI,@Coddes3_OI,@AVOD,@AVOI",
                                              new SqlParameter("IdCita", registroAtencion.IdCita),
                                              new SqlParameter("NroHistoriaClinica", registroAtencion.NroHistoriaClinica),
                                              new SqlParameter("Paciente", registroAtencion.Paciente),
                                              new SqlParameter("IdMedico", registroAtencion.IdMedico),
                                              new SqlParameter("Medico", registroAtencion.Medico),
                                              new SqlParameter("IdEspecialidad", registroAtencion.IdEspecialidad),
                                              new SqlParameter("Especialidad", registroAtencion.Especialidad),
                                              new SqlParameter("IdServicio", registroAtencion.IdServicio),
                                              new SqlParameter("Servicio", registroAtencion.Servicio),
                                              new SqlParameter("Financiamiento", registroAtencion.Financiamiento),
                                              new SqlParameter("Diacod1", registroAtencion.Diacod1),
                                              new SqlParameter("Diades1", registroAtencion.Diades1),
                                              new SqlParameter("IdTipoDiagnostico1", registroAtencion.IdTipoDiagnostico1),
                                              new SqlParameter("Diacod2", registroAtencion.Diacod2),
                                              new SqlParameter("Diades2", registroAtencion.Diades2),
                                              new SqlParameter("IdTipoDiagnostico2", registroAtencion.IdTipoDiagnostico2),
                                              new SqlParameter("Diacod3", registroAtencion.Diacod3),
                                              new SqlParameter("Diades3", registroAtencion.Diades3),
                                              new SqlParameter("IdTipoDiagnostico3", registroAtencion.IdTipoDiagnostico3),
                                              new SqlParameter("FechaAtencion", registroAtencion.FechaAtencion),
                                              new SqlParameter("IdUsuario", registroAtencion.IdUsuario),
                                              new SqlParameter("Usuario", registroAtencion.Usuario),
                                              new SqlParameter("CodProc1", registroAtencion.CodProc1),
                                              new SqlParameter("Coddes1", registroAtencion.Coddes1),
                                              new SqlParameter("CodProc2", registroAtencion.CodProc2),
                                              new SqlParameter("Coddes2", registroAtencion.Coddes2),
                                              new SqlParameter("CodProc3", registroAtencion.CodProc3),
                                              new SqlParameter("Coddes3", registroAtencion.Coddes3),
                                              new SqlParameter("IdResidente", registroAtencion.IdResidente),
                                              new SqlParameter("Residente", registroAtencion.Residente),
                                              new SqlParameter("IdTipoCondicionEstablecimiento", registroAtencion.IdTipoCondicionEstablecimiento),
                                              new SqlParameter("IdTipoCondicionServicio", registroAtencion.IdTipoCondicionServicio),
                                              new SqlParameter("Diacod1_OI", registroAtencion.Diacod1_OI),
                                              new SqlParameter("Diades1_OI", registroAtencion.Diades1_OI),
                                              new SqlParameter("IdTipoDiagnostico1_OI", registroAtencion.IdTipoDiagnostico1_OI),
                                              new SqlParameter("codigo", registroAtencion.IdCita),
                                              new SqlParameter("Diacod2_OI", registroAtencion.Diacod2_OI),
                                              new SqlParameter("Diades2_OI", registroAtencion.Diades2_OI),
                                              new SqlParameter("IdTipoDiagnostico2_OI", registroAtencion.IdTipoDiagnostico2_OI),
                                              new SqlParameter("Diacod3_OI", registroAtencion.Diacod3_OI),
                                              new SqlParameter("Diades3_OI", registroAtencion.Diades3_OI),
                                              new SqlParameter("IdTipoDiagnostico3_OI", registroAtencion.IdTipoDiagnostico3_OI),
                                              new SqlParameter("CodProc1_OI", registroAtencion.CodProc1_OI),
                                              new SqlParameter("Coddes1_OI", registroAtencion.Coddes1_OI),
                                              new SqlParameter("CodProc2_OI", registroAtencion.CodProc2_OI),
                                              new SqlParameter("Coddes2_OI", registroAtencion.Coddes2_OI),
                                              new SqlParameter("CodProc3_OI", registroAtencion.CodProc3_OI),
                                              new SqlParameter("Coddes3_OI", registroAtencion.Coddes3_OI),
                                              new SqlParameter("AVOD", registroAtencion.Avod),
                                              new SqlParameter("AVOI", registroAtencion.Avoi));

                // Auditoria
                AuditoriaGeneral auditoria = new AuditoriaGeneral
                {
                    Accion          = "Agregar",
                    NombreTabla     = "Atención",
                    ValoresAntiguos = null,
                    ValoresNuevos   = JsonConvert.SerializeObject(registroAtencion),
                    IdUsuario       = registroAtencion.IdUsuario
                };
                this._gestorDeAuditoria.AgregarAuditoria(auditoria);

                return(new RespuestaBD
                {
                    Id = 1,
                    Mensaje = "Se guardó correctamente la atención"
                });
            }
        }