Exemplo n.º 1
0
        public bool RotarFoto(string direccion)
        {
            if (this.PathArchivo != null)
            {
                string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(this.CapacitadoID);
                string pathDirectorio = Path.Combine(HttpContext.Current.Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                var pathArchivoImagen = Path.Combine(pathDirectorio, this.PathArchivo.NombreArchivo);

                using (Image img = Image.FromFile(pathArchivoImagen))
                {
                    //rotate the picture by 90 degrees and re-save the picture as a Jpeg

                    if (direccion == "i") //si se va a rotar a la izquierda
                    {
                        img.RotateFlip(RotateFlipType.Rotate270FlipNone);
                    }
                    else if (direccion == "d")
                    {
                        img.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    }
                    else
                    {
                        return(false);
                    }

                    img.Save(pathArchivoImagen, System.Drawing.Imaging.ImageFormat.Jpeg);
                }

                return(true);
            }
            return(false);
        }
Exemplo n.º 2
0
        public bool CargarFoto(HttpPostedFileBase foto)
        {
            if (foto != null && foto.ContentLength > 0)
            {
                string nombreArchivo = PathArchivoHelper.GetInstance().ObtenerNombreFotoCapacitado(this.CapacitadoID,
                                                                                                   System.IO.Path.GetExtension(foto.FileName));

                string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(this.CapacitadoID);

                string pathDirectorio = Path.Combine(HttpContext.Current.Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                this.PathArchivo = PathArchivoHelper.GetInstance().ObtenerPathArchivo(nombreArchivo,
                                                                                      carpetaArchivo,
                                                                                      pathDirectorio,
                                                                                      foto,
                                                                                      TiposArchivo.FotoCapacitado);

                var pathArchivoImagen = Path.Combine(pathDirectorio, nombreArchivo);

                Stream streamSinEXIF = new MemoryStream();

                using (Image imgOriginal = Image.FromFile(pathArchivoImagen))
                {
                    //rotate the picture by 90 degrees and re-save the picture as a Jpeg
                    //imgOriginal.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    //img.Save(pathArchivoImagen, System.Drawing.Imaging.ImageFormat.Jpeg);

                    var streamOriginal = new MemoryStream();
                    imgOriginal.Save(streamOriginal, ImageFormat.Jpeg);

                    // If you're going to read from the stream, you may need to reset the position to the start
                    streamOriginal.Position = 0;

                    streamSinEXIF = ImageHelper.GetInstance().PatchAwayExif(streamOriginal, streamSinEXIF);
                }

                Image imgSinEXIF = Image.FromStream(streamSinEXIF);

                //si la imagen está apaisada, rotarla 90 grados
                //20201003 - GF: hasta que se resuelva el cropping de las fotos no se capturan a través de la cámara
                //               y no es neceario rotarla

                /*
                 * if (imgSinEXIF.Width > imgSinEXIF.Height)
                 *  imgSinEXIF.RotateFlip(RotateFlipType.Rotate90FlipNone);
                 */

                imgSinEXIF.Save(pathArchivoImagen, System.Drawing.Imaging.ImageFormat.Jpeg);

                return(true);
            }

            return(false);
        }
Exemplo n.º 3
0
        public ActionResult Edit([Bind(Include = "CapacitadoID,Nombre,Apellido,Documento,Fecha,Telefono,EmpresaID,TipoDocumentoID,PathArchivoID")] Capacitado capacitado, HttpPostedFileBase upload, string previousUrl)
        {
            if (ModelState.IsValid)
            {
                PathArchivo pathArchivo = null;

                if (upload != null && upload.ContentLength > 0)
                {
                    string nombreArchivo = PathArchivoHelper.GetInstance().ObtenerNombreFotoCapacitado(capacitado.CapacitadoID,
                                                                                                       System.IO.Path.GetExtension(upload.FileName));

                    string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(capacitado.CapacitadoID);

                    string pathDirectorio = Path.Combine(Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                    pathArchivo = PathArchivoHelper.GetInstance().ObtenerPathArchivo(nombreArchivo,
                                                                                     carpetaArchivo,
                                                                                     pathDirectorio,
                                                                                     upload,
                                                                                     TiposArchivo.FotoCapacitado);

                    db.Entry(pathArchivo).State = EntityState.Added;

                    capacitado.PathArchivo = pathArchivo;
                    //db.SaveChanges();
                }

                capacitado.SetearAtributosControl();

                /*
                 * if (pathArchivo != null)
                 *  capacitado.PathArchivoID = pathArchivo.PathArchivoId;
                 */

                db.Entry(capacitado).State = EntityState.Modified;
                db.SaveChanges();

                if (!string.IsNullOrEmpty(previousUrl))
                {
                    return(Redirect(previousUrl));
                }
                else
                {
                    return(RedirectToAction("Details", new { id = capacitado.CapacitadoID }));
                }
            }
            ViewBag.EmpresaID       = new SelectList(db.Empresas.OrderBy(e => e.NombreFantasia).ToList(), "EmpresaID", "NombreFantasia", capacitado.EmpresaID);
            ViewBag.TipoDocumentoID = new SelectList(db.TiposDocumento.ToList(), "TipoDocumentoID", "Descripcion", capacitado.TipoDocumentoID);

            //hubo un error. Se regresa a la pantalla de edición
            return(View(capacitado));
        }
Exemplo n.º 4
0
        public void CambiarExtensionFotoAJPG()
        {
            if (this.PathArchivo != null && this.PathArchivo.NombreArchivo.Contains(".jpeg"))
            {
                string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(this.CapacitadoID);
                string pathDirectorio = Path.Combine(HttpContext.Current.Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                var pathArchivoImagenAnterior = Path.Combine(pathDirectorio, this.PathArchivo.NombreArchivo);
                var pathArchivoImagenNuevo    = Path.Combine(pathDirectorio, this.PathArchivo.NombreArchivo.Replace(".jpeg", ".jpg"));

                System.IO.File.Move(pathArchivoImagenAnterior, pathArchivoImagenNuevo);
            }
        }
Exemplo n.º 5
0
        public ActionResult Create([Bind(Include = "CapacitadoID,Nombre,Apellido,Documento,Fecha,Telefono,EmpresaID,TipoDocumentoID")] Capacitado capacitado, HttpPostedFileBase upload, int?jornadaId)
        {
            if (ModelState.IsValid)
            {
                capacitado.SetearAtributosControl();

                db.Capacitados.Add(capacitado);
                db.SaveChanges();

                if (upload != null && upload.ContentLength > 0)
                {
                    string nombreArchivo = PathArchivoHelper.GetInstance().ObtenerNombreFotoCapacitado(capacitado.CapacitadoID,
                                                                                                       System.IO.Path.GetExtension(upload.FileName));

                    string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(capacitado.CapacitadoID);

                    string pathDirectorio = Path.Combine(Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                    capacitado.PathArchivo = PathArchivoHelper.GetInstance().ObtenerPathArchivo(nombreArchivo,
                                                                                                carpetaArchivo,
                                                                                                pathDirectorio,
                                                                                                upload,
                                                                                                TiposArchivo.FotoCapacitado);

                    db.Entry(capacitado).State = EntityState.Modified;
                    db.SaveChanges();
                }

                //si durante la cración se recibe un id de jornada, el capacitado es agregado a esa jornada
                if (jornadaId != null)
                {
                    Jornada j = db.Jornada.Find(jornadaId);

                    if (j == null)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                    }

                    //se vuelve a cargar el capacitado para leer entidades asociadas
                    capacitado = db.Capacitados.Where(c => c.CapacitadoID == capacitado.CapacitadoID).Include(c => c.TipoDocumento).FirstOrDefault();

                    var nuevoRC = new RegistroCapacitacion();
                    nuevoRC.SetearAtributosControl();

                    nuevoRC.Jornada          = j;
                    nuevoRC.Capacitado       = capacitado;
                    nuevoRC.Nota             = 0;
                    nuevoRC.Aprobado         = true;
                    nuevoRC.FechaVencimiento = j.ObtenerFechaVencimiento(true);

                    if (j.PermiteEnviosOVAL)
                    {
                        nuevoRC.EnvioOVALEstado = EstadosEnvioOVAL.PendienteEnvio;
                    }
                    else
                    {
                        nuevoRC.EnvioOVALEstado = EstadosEnvioOVAL.NoEnviar;
                    }

                    db.RegistroCapacitacion.Add(nuevoRC);
                    db.SaveChanges();

                    //si la incripción fue registrada por un usuario con perfil para inscripciones externas, se notifica por email
                    if (System.Web.HttpContext.Current.User.IsInRole("InscripcionesExternas"))
                    {
                        NotificacionesEMailHelper.GetInstance().EnviarEmailsNotificacionInscripcionExterna(nuevoRC, true);
                    }

                    return(RedirectToAction("Details", "Jornadas", new { id = jornadaId }));
                }

                return(RedirectToAction("Details", "Capacitados", new { id = capacitado.CapacitadoID }));
            }

            ViewBag.TipoDocumentoID = new SelectList(db.TiposDocumento.ToList(), "TipoDocumentoID", "Descripcion", capacitado.TipoDocumentoID);
            ViewBag.EmpresaID       = new SelectList(db.Empresas.OrderBy(e => e.NombreFantasia).ToList(), "EmpresaID", "NombreFantasia", capacitado.EmpresaID);

            return(View(capacitado));
        }
Exemplo n.º 6
0
        private RespuestaOVAL EnviarDatosRegistroSOAP(RegistroCapacitacion r)
        {
            const string module = "enviosOVAL";

            DateTime fechaJornada = r.Jornada.Fecha;

            ServiceEnviarDatosFotoOVAL.WebServiceResponse rOVAL;

            try
            {
                string mensajelog = string.Format("Iniciando envío de datos\r\n\t{0}\r\n\t{1}\r\n\t{2}\r\n\t{3}",
                                                  r.Capacitado.DocumentoCompleto,
                                                  r.Capacitado.NombreCompleto,
                                                  r.Jornada.JornadaIdentificacionCompleta,
                                                  r.Estado.ToString());

                LogHelper.GetInstance().WriteMessage(module, mensajelog);

                string direccionServicioEnviarDatosOVAL = r.Jornada.Curso.PuntoServicio.Direccion;

                LogHelper.GetInstance().WriteMessage(module, string.Format("Conectándose al servicio ubicado en {0}", direccionServicioEnviarDatosOVAL));

                BasicHttpsBinding binding = new BasicHttpsBinding();
                EndpointAddress   address = new EndpointAddress(direccionServicioEnviarDatosOVAL);

                ServiceEnviarDatosFotoOVAL.ServiceSoapClient sOVAL = new ServiceEnviarDatosFotoOVAL.ServiceSoapClient(binding, address);
                ServiceEnviarDatosFotoOVAL.TokenSucurity     token = new ServiceEnviarDatosFotoOVAL.TokenSucurity
                {
                    Username = r.Jornada.Curso.PuntoServicio.Usuario,
                    Password = r.Jornada.Curso.PuntoServicio.Password
                };

                //Se invoca el método para validar las credenciaes del usuario (devuelve un string)
                string responseToken = sOVAL.AuthenticationUser(token);

                token.AuthenToken = responseToken;

                byte[] fotoCapacitadoAsArray = null;

                if (r.Capacitado.PathArchivo != null)
                {
                    if (r.Capacitado.PathArchivo.NombreArchivo.ToLower().Contains(".jpeg"))
                    {
                        if (bool.Parse(ConfiguracionHelper.GetInstance().GetValue("ForzarExtensionArchivoImagenJPG", "EnvioOVAL")))
                        {
                            if (CapacitadoHelper.GetInstance().CambiarExtensionFotoAJPG(r.Capacitado, this.db))
                            {
                                LogHelper.GetInstance().WriteMessage(module, string.Format("Se modificó la extensión del archivo {0}", r.Capacitado.PathArchivo.NombreArchivo));
                            }
                            else
                            {
                                LogHelper.GetInstance().WriteMessage(module, string.Format("No se pudo modificar la extensión del archivo {0}", r.Capacitado.PathArchivo.NombreArchivo));
                            }
                        }
                        else
                        {
                            LogHelper.GetInstance().WriteMessage(module, string.Format("No se modificará la extensión del archivo {0} porque está deshabilitada por configuración", r.Capacitado.PathArchivo.NombreArchivo));
                        }
                    }

                    //se obtiene el path donde está almacenada la imagen que se enviará al web service
                    string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(r.Capacitado.CapacitadoID);
                    string pathDirectorio = Path.Combine(HttpContext.Current.Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                    var pathArchivoImagen = Path.Combine(pathDirectorio, r.Capacitado.PathArchivo.NombreArchivo);

                    fotoCapacitadoAsArray = this.GetImageAsByteArray(pathArchivoImagen);
                }

                rOVAL = sOVAL.get_induccion(token,
                                            r.Capacitado.TipoDocumento.TipoDocumentoOVAL,
                                            r.Capacitado.Documento,
                                            r.Capacitado.Nombre,
                                            r.Capacitado.Apellido,
                                            string.Empty,
                                            r.Capacitado.Empresa.RUT,
                                            r.Capacitado.Empresa.NombreFantasia,
                                            "CAP_SEG",
                                            r.Estado == EstadosRegistroCapacitacion.Aprobado ? "APR" : "REC",
                                            string.Format("{0}-{1}-{2}", fechaJornada.Day.ToString().PadLeft(2, '0'), fechaJornada.Month.ToString().PadLeft(2, '0'), fechaJornada.Year.ToString()),
                                            string.Empty,
                                            fotoCapacitadoAsArray);

                LogHelper.GetInstance().WriteMessage(module, string.Format("Conexión finalizada\r\n\tResult: {0}\r\n\tErrorMessage: {1}", rOVAL.Result, rOVAL.ErrorMessage));

                //si la propiedad Result tiene contenido, el registro se recibió correctamente
                if (rOVAL.Result != string.Empty)
                {
                    LogHelper.GetInstance().WriteMessage(module, "El registro fue recibido por el sistema OVAL");
                    return(new RespuestaOVAL()
                    {
                        Codigo = 0, Mensaje = rOVAL.Result
                    });
                }
                else
                {
                    LogHelper.GetInstance().WriteMessage(module, string.Format("El registro fue rechazado por el sistema OVAL ({0})", rOVAL.ErrorMessage));
                    return(new RespuestaOVAL()
                    {
                        Codigo = 1, Mensaje = rOVAL.ErrorMessage
                    });
                }
            }
            catch (Exception e)
            {
                LogHelper.GetInstance().WriteMessage(module, e.Message);
                return(new RespuestaOVAL()
                {
                    Codigo = -1, Mensaje = e.Message
                });
            }
        }
Exemplo n.º 7
0
        private RespuestaOVAL EnviarDatosRegistroRest(RegistroCapacitacion r)
        {
            DateTime fechaJornada = r.Jornada.Fecha;

            string fotoCapacitadoAsBase64 = String.Empty;

            if (r.Capacitado.PathArchivo != null)
            {
                //se obtiene el path donde está almacenada la imagen que se enviará al web service
                string carpetaArchivo = PathArchivoHelper.GetInstance().ObtenerCarpetaFotoCapacitado(r.Capacitado.CapacitadoID);
                string pathDirectorio = Path.Combine(HttpContext.Current.Server.MapPath("~/Images/FotosCapacitados/"), carpetaArchivo);

                var pathArchivoImagen = Path.Combine(pathDirectorio, r.Capacitado.PathArchivo.NombreArchivo);

                //byte[] fotoCapacitadoAsArray = null;
                byte[] fotoCapacitadoAsArray = this.GetImageAsByteArray(pathArchivoImagen);
                fotoCapacitadoAsBase64 = Convert.ToBase64String(fotoCapacitadoAsArray);
            }

            PuntoServicio puntoServicioRest = r.Jornada.Curso.PuntoServicio;

            var client  = new RestClient(puntoServicioRest.Direccion);
            var request = new RestRequest(puntoServicioRest.DireccionRequest, Method.POST)
            {
                RequestFormat = DataFormat.Json
            };

            string tokenOAuthOVAL = ObtenerTokenOAuthOVAL(puntoServicioRest);

            if (tokenOAuthOVAL != null)
            {
                request.AddHeader("Authorization", "Bearer " + tokenOAuthOVAL);

                request.AddJsonBody(
                    new {
                    tipo_doc               = r.Capacitado.TipoDocumento.TipoDocumentoOVAL,
                    rut_trabajador         = r.Capacitado.Documento,
                    nombres_trabajador     = r.Capacitado.Nombre,
                    ape_paterno_trabajador = r.Capacitado.Apellido,
                    ape_materno_trabajador = string.Empty,
                    rut_contratista        = r.Capacitado.Empresa.RUT,
                    nombre_contratista     = r.Capacitado.Empresa.NombreFantasia,
                    tipo_induccion         = "CAP_SEG",
                    estado_induccion       = r.Estado == EstadosRegistroCapacitacion.Aprobado ? "APR" : "REC",
                    fecha_induccion        = string.Format("{0}-{1}-{2}", fechaJornada.Day.ToString().PadLeft(2, '0'), fechaJornada.Month.ToString().PadLeft(2, '0'), fechaJornada.Year.ToString()),
                    imagen = fotoCapacitadoAsBase64
                });

                var tResponse = client.Execute(request);

                if (tResponse.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    string respuestaServicio = ObtenerRespuestaServicioREST(tResponse.Content);
                    int    codigoRet         = 0; //0 es el código correspondiente a envío exitoso

                    if (respuestaServicio != "ok")
                    {
                        codigoRet = 1; //indica que hubo un error al invocar el servicio
                    }
                    return(new RespuestaOVAL()
                    {
                        Codigo = codigoRet, Mensaje = respuestaServicio
                    });
                }
                else
                {
                    return new RespuestaOVAL()
                           {
                               Codigo = -1, Mensaje = "Error al invocar el servicio"
                           }
                };
            }
            else
            {
                return new RespuestaOVAL()
                       {
                           Codigo = -1, Mensaje = "Error al invocar el servicio de autenticación (token)"
                       }
            };
        }