Example #1
0
        /// <summary>
        ///  Deshabilitamos Certificado
        /// </summary>
        private void deshabilitarCertificado()
        {
            //Establecemos Objeto Resultado
            RetornoOperacion resultado = new RetornoOperacion();

            //Creamos la transacción
            using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
            {
                //Instanciando registro actual
                using (SAT_CL.Global.CertificadoDigital objCertificado = new SAT_CL.Global.CertificadoDigital(Convert.ToInt32(Session["id_registro"])))
                {
                    resultado = objCertificado.DeshabilitaCertificado(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);

                    if (resultado.OperacionExitosa)
                    {
                        //Deshabilitamos Registros Archivo
                        using (ArchivoRegistro objArchivoCer = new
                                                               ArchivoRegistro(objCertificado.idCer))

                            //Deshabilitamos Registro
                            resultado = objArchivoCer.DeshabilitaArchivoRegistro(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);

                        //Validamos Resultado
                        if (resultado.OperacionExitosa)
                        {
                            //Deshabilitamos Registros Archivo
                            using (ArchivoRegistro objArchivoKey = new
                                                                   ArchivoRegistro(objCertificado.idKey))

                                //Deshabilitamos Registro
                                resultado = objArchivoKey.DeshabilitaArchivoRegistro(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);



                            //Si se deshabilitó Correctamente
                            if (resultado.OperacionExitosa)
                            {
                                //Establecemos el id del registro
                                Session["id_registro"] = 0;
                                //Establecemos el estatus de la forma
                                Session["estatus"] = Pagina.Estatus.Nuevo;
                                //Inicializamos la forma
                                inicializaPagina();
                            }
                        }
                    }
                }

                //Validamos Resultado
                if (resultado.OperacionExitosa)
                {
                    scope.Complete();
                }
            }
            //Mostrando error
            lblError.Text = resultado.Mensaje;
        }
Example #2
0
        /// <summary>
        /// Método encargado de Eliminar el Archivo Registro
        /// </summary>
        /// <param name="id_archivo_registro">Registro del Archivo</param>
        /// <param name="id_sesion">Sesión del Usuario que Actualiza el Registro</param>
        /// <returns></returns>
        public string EliminaArchivoRegistro(int id_archivo_registro, 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)
                        {
                            try
                            {
                                //Deshabilitando Registro
                                resultado = archivoRegistro.DeshabilitaArchivoRegistro(user_sesion.id_usuario);
                                using (EventLog eventLog = new EventLog("Application"))
                                {
                                    eventLog.Source = "Application";
                                    eventLog.WriteEntry(string.Format("{1} - {0}", resultado.Mensaje, resultado.OperacionExitosa), EventLogEntryType.Information, 666, 1);
                                }
                            }
                            catch (Exception ex)
                            {
                                resultado = new RetornoOperacion(ex.Message);
                                using (EventLog eventLog = new EventLog("Application"))
                                {
                                    eventLog.Source = "Application";
                                    eventLog.WriteEntry(string.Format("{1} - {0}", resultado.Mensaje, resultado.OperacionExitosa), EventLogEntryType.Information, 666, 1);
                                }
                            }
                        }
                        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());
        }
Example #3
0
        /// <summary>
        /// Metodo encargado de Guardar un Proveedor
        /// </summary>
        private void guardaCertificadoDigital()
        {
            //Validamos que exista carga de Archivos
            if (ViewState["ExtensionArchivoCer"] != null && ViewState["ExtensionArchivoKey"] != null)
            {
                //Validamos Archivo
                if (ViewState["ExtensionArchivoCer"].ToString() == ".cer" && ViewState["ExtensionArchivoKey"].ToString() == ".key")
                {
                    //Declaracion de objeto resultado
                    RetornoOperacion resultado = new RetornoOperacion();
                    //Declaramos Variable para Guardar Certificado
                    int id_Certificado = 0, id_archivo_cer = 0;
                    //Creamos la transacción
                    using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
                    {
                        //De acuerdo al estatus de la pagina
                        switch ((Pagina.Estatus)Session["estatus"])
                        {
                        //Insertando Proveedor
                        case Pagina.Estatus.Nuevo:
                        {
                            resultado = SAT_CL.Global.CertificadoDigital.InsertaCertificado(Convert.ToInt32(ddlEmisor.SelectedValue),
                                                                                            Convert.ToInt32(ddlSucursal.SelectedValue), (SAT_CL.Global.CertificadoDigital.TipoCertificado)
                                                                                            Convert.ToByte(ddlTipo.SelectedValue), txtNuevaContrasena.Text,
                                                                                            txtNuevaContrasenaRevocacion.Text, ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario
                                                                                            );
                            //Asignamos Variable Certificado
                            id_Certificado = resultado.IdRegistro;

                            //Si se insertó Correctamen el Ceriticado Digital
                            if (resultado.OperacionExitosa)
                            {
                                int key = 0;
                                int cer = 0;
                                //Validamos Tipo de Certificado
                                switch ((SAT_CL.Global.CertificadoDigital.TipoCertificado)Convert.ToInt32(ddlTipo.SelectedValue))        //FIEL
                                {
                                case SAT_CL.Global.CertificadoDigital.TipoCertificado.FIEL:
                                    cer = 12;;
                                    key = 14;
                                    break;

                                case SAT_CL.Global.CertificadoDigital.TipoCertificado.CSD:
                                    cer = 13;
                                    key = 15;
                                    break;
                                }

                                //Instanciamos Emisor
                                using (CompaniaEmisorReceptor objEmisor = new CompaniaEmisorReceptor(Convert.ToInt32(ddlEmisor.SelectedValue)))
                                {
                                    //Validamos Emisor
                                    if (objEmisor.id_compania_emisor_receptor > 0)
                                    {
                                        //Construyendo ruta de almacenamiento de certificados
                                        string ruta_certificado = string.Format(@"{0}{1}\{2}-{3}", SAT_CL.CapaNegocio.m_capaNegocio.RegresaVariableCatalogoBD("Directorio Raíz Gestor Archivos SAT"), 114.ToString("0000"), id_Certificado.ToString("0000000"), TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro().ToString("yyMMddHHmmss"));
                                        //Insertamos Archivo Registro .cer
                                        resultado = ArchivoRegistro.InsertaArchivoRegistro(114, id_Certificado, cer,
                                                                                           "", ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario, (byte[])ViewState["BytesArchivoCer"], ruta_certificado + ".cer");
                                        //Validamos Resultado
                                        if (resultado.OperacionExitosa)
                                        {
                                            //Asignando Id de archivo certificado (.cer)
                                            id_archivo_cer = resultado.IdRegistro;

                                            //Insertamos Archivo Registro (.key)
                                            resultado = ArchivoRegistro.InsertaArchivoRegistro(114, id_Certificado, key,
                                                                                               "", ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario, (byte[])ViewState["BytesArchivoKey"], ruta_certificado + ".key");

                                            //Si no se guardó correctamente
                                            if (!resultado.OperacionExitosa)
                                            {
                                                //Deshabilitamos Registros Archivo
                                                using (ArchivoRegistro objArchivoKey = new ArchivoRegistro(id_archivo_cer))
                                                    //Deshabilitamos Registro
                                                    objArchivoKey.DeshabilitaArchivoRegistro(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        resultado = new RetornoOperacion("No se encontrarón datos complementarios Emisor");
                                    }
                                }
                            }

                            break;
                        }

                        case Pagina.Estatus.Edicion:
                        {
                            break;
                        }
                        }
                        //ValidamosResultado
                        if (resultado.OperacionExitosa)
                        {
                            //Finalizamos Transacción
                            scope.Complete();
                        }
                    }
                    //Validamos que la operacion se haya realizado
                    if (resultado.OperacionExitosa)
                    {
                        //Establecemos el id del registro
                        Session["id_registro"] = id_Certificado;
                        //Establecemos el estatus de la forma
                        Session["estatus"] = Pagina.Estatus.Lectura;
                        //Inicializamos la forma
                        inicializaPagina();
                    }

                    //Actualizamos la etiqueta de errores
                    lblError.Text = resultado.Mensaje;
                }
                else
                {
                    lblError.Text = "Los archivos de certificado seleccionados no tienen las extensiones apropiadas.";
                }
            }
            else
            {
                lblError.Text = "Los archivos aún no se han cargado.";
            }
        }
Example #4
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 #5
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());
        }