Esempio n. 1
0
        private Response Existe(ExamenComplementario ExamenComplementario)
        {
            var ecf  = ExamenComplementario.Fecha;
            var ecr  = ExamenComplementario.Resultado.ToUpper().TrimEnd().TrimStart();
            var ecit = ExamenComplementario.IdTipoExamenComplementario;
            var ecif = ExamenComplementario.IdFichaMedica;


            var Respuesta = db.ExamenComplementario.Where(

                p => p.Fecha == ecf &&
                p.Resultado.ToUpper().TrimEnd().TrimStart() == ecr &&
                p.IdTipoExamenComplementario == ecit &&
                p.IdFichaMedica == ecif

                ).FirstOrDefault();

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

            return(new Response
            {
                IsSuccess = false,
                Resultado = Respuesta,
            });
        }
Esempio n. 2
0
        public async Task <Response> Post([FromBody] ExamenComplementarioTransfer examenComplementarioTransfer)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = ""
                    });
                }

                var examenComplementario = new ExamenComplementario
                {
                    IdExamenComplementario = examenComplementarioTransfer.IdExamenComplementario,
                    Fecha     = examenComplementarioTransfer.Fecha,
                    Resultado = examenComplementarioTransfer.Resultado,
                    IdTipoExamenComplementario = examenComplementarioTransfer.IdTipoExamenComplementario,
                    IdFichaMedica = examenComplementarioTransfer.IdFichaMedica,
                };

                var respuesta = Existe(examenComplementario);
                if (!respuesta.IsSuccess)
                {
                    db.ExamenComplementario.Add(examenComplementario);
                    await db.SaveChangesAsync();

                    var id = examenComplementario.IdExamenComplementario;

                    await uploadFileService.UploadFile(examenComplementarioTransfer.Fichero, "ExamenesComplementariosDocumentos", Convert.ToString(id), ".pdf");


                    var seleccionado = db.ExamenComplementario.Find(examenComplementario.IdExamenComplementario);
                    seleccionado.Url = string.Format("{0}/{1}.{2}", "ExamenesComplementariosDocumentos", Convert.ToString(id), "pdf");
                    db.ExamenComplementario.Update(seleccionado);
                    db.SaveChanges();
                    return(new Response
                    {
                        IsSuccess = true,
                        Message = Mensaje.Satisfactorio
                    });
                }

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.ExisteRegistro
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
Esempio n. 3
0
        public async Task <Response> DeleteExamenComplementario([FromRoute] int id)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido,
                    });
                }

                var respuesta = await db.ExamenComplementario.SingleOrDefaultAsync(m => m.IdExamenComplementario == id);

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


                /*borrar fichero*/

                try
                {
                    ExamenComplementario excm = new ExamenComplementario();

                    excm.IdExamenComplementario = id;

                    await DeleteFile(excm);
                }
                catch (Exception ex0) { }

                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.Satisfactorio,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.BorradoNoSatisfactorio,
                });
            }
        }
Esempio n. 4
0
        public async Task <Response> PostExamenComplementario([FromBody] ExamenComplementario ExamenComplementario)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = ""
                    });
                }

                var respuesta = Existe(ExamenComplementario);
                if (!respuesta.IsSuccess)
                {
                    db.ExamenComplementario.Add(ExamenComplementario);
                    await db.SaveChangesAsync();

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

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.ExisteRegistro
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
Esempio n. 5
0
        public async Task <Response> GetFile([FromBody] ExamenComplementario examenComplementario)
        {
            try
            {
                var respuestaFile = uploadFileService.GetFile("ExamenesComplementariosDocumentos", Convert.ToString(examenComplementario.IdExamenComplementario), ".pdf");

                var dato = await db.ExamenComplementario.Where(x => x.IdExamenComplementario == examenComplementario.IdExamenComplementario).FirstOrDefaultAsync();

                return(new Response
                {
                    IsSuccess = true,
                    Message = "Exámen complementario #" + dato.IdExamenComplementario + ", archivo adjunto",
                    Resultado = respuestaFile,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
Esempio n. 6
0
        public async Task <Response> PutExamenComplementario([FromRoute] int id, [FromBody] ExamenComplementario ExamenComplementario)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido
                    });
                }

                var existe = Existe(ExamenComplementario);
                if (existe.IsSuccess)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ExisteRegistro,
                    });
                }

                var Actualizar = await db.ExamenComplementario.Where(x => x.IdExamenComplementario == id).FirstOrDefaultAsync();

                if (Actualizar != null)
                {
                    try
                    {
                        Actualizar.Fecha     = ExamenComplementario.Fecha;
                        Actualizar.Resultado = ExamenComplementario.Resultado;
                        Actualizar.IdTipoExamenComplementario = ExamenComplementario.IdTipoExamenComplementario;
                        Actualizar.IdFichaMedica = ExamenComplementario.IdFichaMedica;


                        db.ExamenComplementario.Update(Actualizar);

                        await db.SaveChangesAsync();

                        return(new Response
                        {
                            IsSuccess = true,
                            Message = Mensaje.Satisfactorio,
                        });
                    }
                    catch (Exception ex)
                    {
                        return(new Response
                        {
                            IsSuccess = false,
                            Message = Mensaje.Error,
                        });
                    }
                }


                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.ExisteRegistro,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Excepcion
                });
            }
        }
Esempio n. 7
0
        public async Task <Response> PostUpdateFiles([FromBody] ExamenComplementarioTransfer examenComplementarioTransfer)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = ""
                    });
                }


                var Actualizar = await db.ExamenComplementario.Where(x => x.IdExamenComplementario == examenComplementarioTransfer.IdExamenComplementario).FirstOrDefaultAsync();

                Actualizar.Fecha     = examenComplementarioTransfer.Fecha;
                Actualizar.Resultado = examenComplementarioTransfer.Resultado;
                Actualizar.IdTipoExamenComplementario = examenComplementarioTransfer.IdTipoExamenComplementario;
                Actualizar.IdFichaMedica = examenComplementarioTransfer.IdFichaMedica;

                /*borrar fichero*/

                try
                {
                    ExamenComplementario excm = new ExamenComplementario();

                    excm.IdExamenComplementario = examenComplementarioTransfer.IdExamenComplementario;

                    await DeleteFile(excm);
                }
                catch (Exception ex0) { }

                /* Crear nuevo fichero */

                var id = examenComplementarioTransfer.IdExamenComplementario;

                await uploadFileService.UploadFile(examenComplementarioTransfer.Fichero, "ExamenesComplementariosDocumentos", Convert.ToString(id), ".pdf");


                /* Edito la nueva Url */

                //var seleccionado = db.ExamenComplementario.Find(examenComplementario.IdExamenComplementario);
                Actualizar.Url = string.Format("{0}/{1}.{2}", "ExamenesComplementariosDocumentos", Convert.ToString(id), "pdf");

                db.ExamenComplementario.Update(Actualizar);
                db.SaveChanges();

                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.Satisfactorio
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }