private Response Existe(PersonaEnfermedad PersonaEnfermedad)
        {
            var institucionemite = PersonaEnfermedad.InstitucionEmite.ToString().ToUpper();
            var idtipoenfermedad = PersonaEnfermedad.IdTipoEnfermedad;
            var idpersona        = PersonaEnfermedad.IdPersona;

            var PersonaEnfermedadrespuesta = db.PersonaEnfermedad.Where(p => p.InstitucionEmite == institucionemite &&
                                                                        p.IdTipoEnfermedad == idtipoenfermedad &&
                                                                        p.IdPersona == idpersona).FirstOrDefault();

            if (PersonaEnfermedadrespuesta != null)
            {
                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.ExisteRegistro,
                    Resultado = PersonaEnfermedadrespuesta,
                });
            }

            return(new Response
            {
                IsSuccess = false,
                Resultado = PersonaEnfermedadrespuesta,
            });
        }
Beispiel #2
0
        public async Task <Response> EliminarPersonaEnfermedad([FromBody] PersonaEnfermedad personaEnfermedad)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido,
                    });
                }

                var respuesta = await db.PersonaEnfermedad.SingleOrDefaultAsync(m => m.IdPersonaEnfermedad == personaEnfermedad.IdPersonaEnfermedad && m.IdPersona == personaEnfermedad.IdPersona);

                if (respuesta == null)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.RegistroNoEncontrado,
                    });
                }
                db.PersonaEnfermedad.Remove(respuesta);
                await db.SaveChangesAsync();

                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.Satisfactorio,
                });
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwTH),
                    ExceptionTrace       = ex,
                    Message              = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "",
                });

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
        public async Task <Response> PutPersonaEnfermedad([FromRoute] int id, [FromBody] PersonaEnfermedad PersonaEnfermedad)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido
                    });
                }

                var existe = Existe(PersonaEnfermedad);
                var PersonaEnfermedadActualizar = (PersonaEnfermedad)existe.Resultado;
                if (
                    existe.IsSuccess &&
                    PersonaEnfermedadActualizar.IdPersonaEnfermedad != PersonaEnfermedad.IdPersonaEnfermedad
                    )
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ExisteRegistro,
                    });
                }

                var PersonaEnfermedadAct = await db.PersonaEnfermedad.Where(x => x.IdPersonaEnfermedad == PersonaEnfermedad.IdPersonaEnfermedad).FirstOrDefaultAsync();

                PersonaEnfermedadAct.IdTipoEnfermedad = PersonaEnfermedad.IdTipoEnfermedad;
                PersonaEnfermedadAct.IdPersona        = PersonaEnfermedad.IdPersona;
                PersonaEnfermedadAct.InstitucionEmite = PersonaEnfermedad.InstitucionEmite.ToString().ToUpper();

                await db.SaveChangesAsync();

                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.GuardadoSatisfactorio,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.Excepcion,
                });
            }
        }
        public async Task <Response> PostPersonaEnfermedad([FromBody] PersonaEnfermedad PersonaEnfermedad)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = ""
                    });
                }

                var respuesta = Existe(PersonaEnfermedad);
                if (!respuesta.IsSuccess)
                {
                    PersonaEnfermedad.InstitucionEmite = PersonaEnfermedad.InstitucionEmite.ToString().ToUpper();

                    db.PersonaEnfermedad.Add(PersonaEnfermedad);
                    await db.SaveChangesAsync();

                    return(new Response
                    {
                        IsSuccess = true,
                        Message = Mensaje.GuardadoSatisfactorio
                    });
                }

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.ExisteRegistro,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
Beispiel #5
0
        public async Task <Response> InsertarPersonaEnfermedad([FromBody] PersonaEnfermedad personaEnfermedad)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido,
                    });
                }
                db.PersonaEnfermedad.Add(personaEnfermedad);
                await db.SaveChangesAsync();

                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.Satisfactorio
                });
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwTH),
                    ExceptionTrace       = ex,
                    Message              = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "",
                });

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }