Example #1
0
        /// <summary>
        /// Método Público encaragdo de Guardar los Archivos de cada Registro
        /// </summary>
        /// <param name="id_registro">Parametro que hace Referencia al Registro</param>
        /// <param name="id_tabla">Parametro que hace Referencia a la Tabla</param>
        /// <param name="id_compania">Compañia Emisora</param>
        /// <param name="id_archivo_tipo">Tipo de Archivo</param>
        /// <param name="referencia">Referencia del Archivo (Nombre)</param>
        /// <param name="archivo">Archivo en Formato Base 64</param>
        /// <param name="id_usuario">Usuario que Actualiza el Registro</param>
        /// <returns></returns>
        public string GuardaArchivoRegistro(int id_registro, int id_tabla, int id_compania, int id_archivo_tipo, string referencia, string archivo, int id_usuario)
        {
            //Declarando Objeto de Retorno
            RetornoOperacion resultado = null;

            //Instanciando el Tipo de Configuración del Archivo
            using (ArchivoTipoConfiguracion atc = new ArchivoTipoConfiguracion(id_archivo_tipo, id_compania, id_tabla))
            {
                //Validando si existe la Configuración
                if (atc.id_archivo_tipo_configuracion > 0)
                {
                    //Declarando Arreglo de Bytes
                    byte[] fileArray = Convert.FromBase64String(archivo);

                    //Validando que existan
                    if (fileArray != null)
                    {
                        //Instanciando Tipo del Archivo
                        using (ArchivoTipo at = new ArchivoTipo(atc.id_archivo_tipo))
                        {
                            //Validando que exista el Tipo
                            if (at.id_archivo_tipo > 0)
                            {
                                //Declaramos variable para almacenar ruta
                                string ruta = "";
                                //Armando ruta de guardado físico de archivo
                                //Compuesta de un path genérico para esta ventana, el Id de Tabla e Id de Registro, más el nombre asignado al archivo (incluyendo extensión)
                                ruta = string.Format(@"{0}{1}\{2}-{3}{4}", SAT_CL.CapaNegocio.m_capaNegocio.RegresaVariableCatalogoBD("Directorio Raíz Gestor Archivos SAT"), atc.id_tabla.ToString("0000"), id_registro.ToString("0000000"), DateTime.Now.ToString("yyMMddHHmmss"), at.extension);

                                //Insertamos Registro
                                resultado = SAT_CL.Global.ArchivoRegistro.InsertaArchivoRegistro(atc.id_tabla, id_registro, atc.id_archivo_tipo_configuracion, referencia.ToUpper(), id_usuario, fileArray, ruta);
                            }
                            else
                            {
                                //Instanciando Excepcion
                                resultado = new RetornoOperacion("No se encontro el tipo del Archivo");
                            }
                        }
                    }
                    else
                    {
                        //Instanciando Excepcion
                        resultado = new RetornoOperacion("No existe el Archivo");
                    }
                }
                else
                {
                    //Instanciando Excepcion
                    resultado = new RetornoOperacion("No se encontraron datos complementarios Detalle Archivo");
                }
            }

            //Devolviendo resultado Obtenido
            return(resultado.ToXMLString());
        }
Example #2
0
        /// <summary>
        /// Método encargado de Obtener el Archivo en Formato Base64 de un Registro
        /// </summary>
        /// <param name="id_archivo_registro">Registro del Archivo</param>
        /// <returns>Archivo en Formato XML</returns>
        public string ObtieneArchivoRegistroBase64(int id_archivo_registro)
        {
            //Declarando Objeto de Retorno
            XDocument document = new XDocument();

            //Añadiendo Nodo Principal
            document.Add(new XElement("ArchivoRegistro"));

            //Declarando Elemento por Añadir
            XElement archivoBase64;
            XElement extension;
            XElement nombreArchivo;

            //Declarando Variables Auxiliares
            byte[] archivoBytes = null;
            string base64 = "", ext = "", name = "";

            //Instanciando Archivo Registro
            using (ArchivoRegistro archivo_registro = new ArchivoRegistro(id_archivo_registro))
            {
                //Validando que exista el Archivo
                if (archivo_registro.habilitar)
                {
                    //Instanciando Archivo Tipo Configuración
                    using (ArchivoTipoConfiguracion atc = new ArchivoTipoConfiguracion(archivo_registro.id_archivo_tipo_configuracion))
                    {
                        //Validando que exista la Configuración del Tipo de Archivo
                        if (atc.habilitar)
                        {
                            //Instanciando Tipo de Archivo
                            using (ArchivoTipo at = new ArchivoTipo(atc.id_archivo_tipo))
                            {
                                //Validando que exista el Tipo de Archivo
                                if (at.habilitar)
                                {
                                    try
                                    {
                                        //Obteniendo Arreglo de Bytes de la Ruta
                                        archivoBytes = System.IO.File.ReadAllBytes(archivo_registro.url);

                                        //Convirtiendo Archivo a Base 64
                                        base64 = Convert.ToBase64String(archivoBytes);
                                    }
                                    catch { }

                                    //Asignando Valores
                                    ext  = at.extension;
                                    name = archivo_registro.referencia;
                                }
                            }
                        }
                    }
                }

                //Inicializando Elemento
                extension     = new XElement("Extension", ext);
                nombreArchivo = new XElement("NombreArchivo", name);
                archivoBase64 = new XElement("StreamBase64", base64);
            }

            //Añadiendo a Nodo Principal
            document.Element("ArchivoRegistro").Add(extension);
            document.Element("ArchivoRegistro").Add(nombreArchivo);
            document.Element("ArchivoRegistro").Add(archivoBase64);

            //Devolviendo Resultado Obtenido
            return(document.ToString());
        }
Example #3
0
        /// <summary>
        /// Método encargado de Actualizar el Archivo.
        /// </summary>
        /// <param name="id_archivo_registro">Parametro que hace referencia al Registro del Archivo</param>
        /// <param name="referencia">Referencia del Archivo (Nombre)</param>
        /// <param name="archivo">Archivo en Formato Base 64</param>
        /// <param name="id_sesion">Sesión del Usuario que Actualiza el Registro</param>
        /// <returns>Retorno Operación en Formato XML</returns>
        public string ActualizaArchivoRegistro(int id_archivo_registro, string referencia, string archivo, int id_sesion)
        {
            //Declarando Objeto de Retorno
            RetornoOperacion resultado = null;

            //Instanciando la Sesión de Usuario
            using (SAT_CL.Seguridad.UsuarioSesion user_sesion = new SAT_CL.Seguridad.UsuarioSesion(id_sesion))
            {
                //Validando que la Sesión este Activa
                if (user_sesion.habilitar && user_sesion.EstatusSesion == SAT_CL.Seguridad.UsuarioSesion.Estatus.Activo)
                {
                    //Instanciando Archivo Registro
                    using (ArchivoRegistro archivoRegistro = new ArchivoRegistro(id_archivo_registro))
                    {
                        //Validando que exista el Archivo
                        if (archivoRegistro.habilitar)
                        {
                            //Instanciando Referencias
                            using (ArchivoTipoConfiguracion atc = new ArchivoTipoConfiguracion(archivoRegistro.id_archivo_tipo_configuracion))
                                using (ArchivoTipo at = new ArchivoTipo(atc.id_archivo_tipo))
                                {
                                    //Declarando Arreglo de Bytes
                                    byte[] fileArray = Convert.FromBase64String(archivo);

                                    //Validando que existan
                                    if (fileArray != null)
                                    {
                                        //Declaramos variable para almacenar ruta
                                        string ruta = "";

                                        //Armando ruta de guardado físico de archivo
                                        //Compuesta de un path genérico para esta ventana, el Id de Tabla e Id de Registro, más el nombre asignado al archivo (incluyendo extensión)
                                        ruta = string.Format(@"{0}{1}\{2}-{3}{4}", SAT_CL.CapaNegocio.m_capaNegocio.RegresaVariableCatalogoBD("Directorio Raíz Gestor Archivos SAT"), archivoRegistro.id_tabla.ToString("0000"), archivoRegistro.id_registro.ToString("0000000"), Fecha.ObtieneFechaEstandarMexicoCentro().ToString("yyMMddHHmmss"), at.extension);

                                        try
                                        {
                                            //Actualizando Archivo
                                            resultado = archivoRegistro.ActualizaArchivoRegistro(ruta, referencia.ToUpper(), user_sesion.id_usuario, fileArray);
                                            using (EventLog eventLog = new EventLog("Application"))
                                            {
                                                eventLog.Source = "Application";
                                                eventLog.WriteEntry(string.Format("{0} - {1}", resultado.Mensaje, ruta), EventLogEntryType.Information, 666, 1);
                                            }
                                        }
                                        catch (Exception e)
                                        {
                                            //Instanciando Excepción
                                            resultado = new RetornoOperacion(e.Message);
                                            using (EventLog eventLog = new EventLog("Application"))
                                            {
                                                eventLog.Source = "Application";
                                                eventLog.WriteEntry(string.Format("{0} - {1}", resultado.Mensaje, ruta), EventLogEntryType.Information, 666, 1);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        //Instanciando Excepcion
                                        resultado = new RetornoOperacion("No existe el Archivo");
                                    }
                                }
                        }
                        else
                        {
                            //Instanciando Excepción
                            resultado = new RetornoOperacion("No existe el Registro del Archivo");
                        }
                    }
                }
                else
                {
                    //Instanciando Excepción
                    resultado = new RetornoOperacion("La Sesión no esta Activa");
                }
            }

            //Devolviendo resultado Obtenido
            return(resultado.ToXMLString());
        }