//=======================================================================
// Instituto Costarricense de Acueductos y Alcantarillados. - 2012
// Sistema de Autoevaluación para Control Interno
//
// Explicación de los contenidos del archivo.
// =========================================================================
// Historial
// PERSONA 			            DIA – MES - AÑO		    DESCRIPCIÓN
// Pedro Leiva Cerdas       	10 – Febrero  - 2014	            Entrega del sistema. (Versión original del archivo)
//								Clase para trabajar con VISION 2020 
// //======================================================================
// Derechos Reservados (C) 2012 AyA.
// ESTE CÓDIGO ES PROVEÍDO “TAL CUAL ES” SIN GARANTÍA ALGUNA
// DE NINGÚN TIPO, SEA IMPLICITA O EXPLICITA.
// NO SE PERMITE SU REPRODUCCIÓN PARCIAL O TOTAL, NI SU COMERCIALIZACIÓN
//======================================================================
using System;
using BASEBL; // Para usar a enumsBL
using System.IO;
using System.Web;
using System.Text;
using System.Data;
using System.Linq;
using System.Web.UI;
using System.Collections;
using System.Configuration;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text.RegularExpressions;
using System.Net;

public partial class Documento : General
{
    //Se hace referencia del WS
    vision2020serverapionline.wsapi wsVision2020;

    public string const_strUsuario = ConfigurationSettings.AppSettings["const_strUsuario"].ToString();
    public string const_strClave = ConfigurationSettings.AppSettings["const_strClave"].ToString();
    public string const_strArchivadores = ConfigurationSettings.AppSettings["const_strArchivadores"].ToString();
    public string const_strGaveta = ConfigurationSettings.AppSettings["const_strGaveta"].ToString();
    public string strIdGaveta = ""; //para este sistema sevri simpre serà ="00000035" pero mejor lo buscamos
    public string const_strLlaves = ConfigurationSettings.AppSettings["const_strLlaves"].ToString(); //para este sistema SDI estas son las llaves por default

    //public const string const_strUsuario = "sdaa";
    //public const string const_strClave = "usersdaa";
    //public const string const_strGaveta = "Disponibilidades";

    /// <summary>
    /// Método que se utiliza para retornar un DS con el àrbol Estructura
    /// </summary>
    /// 
    public DataSet dsEstructura(string strUsuario, string strClave, bool bolMappingTypeAttribute)
    {
        DataSet dsArbolEstructura = new DataSet();
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            dsArbolEstructura = wsVision2020.Arbol_Estructura(strUsuario, strClave, bolMappingTypeAttribute);
        }
        catch (Exception ex)
        {
            return null;
        }
        return dsArbolEstructura;
    }

    /// <summary>
    /// Método que se utiliza para retornar el id de la Carpeta o sea la DEPENDENCIA que nos interesa
    /// si retorna un null es que no encontro la Carpeta
    /// </summary>
    /// 
    private string Id_Carpeta(string strLlaves, string strValores)
    {
        DataSet dsCarpeta = new DataSet();
        string strId_Carpeta = null;
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            dsCarpeta = wsVision2020.Devuelve_Ids_Gaveta_Carpeta(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strLlaves, strValores);
            if (dsCarpeta.Tables[0].Rows.Count > 0)
            {
                strId_Carpeta = dsCarpeta.Tables[0].Rows[1]["valor"].ToString();
            }
        }
        catch (Exception ex)
        {
            return strId_Carpeta;
        }
        return strId_Carpeta;
    }

    /// <summary>
    /// Método que se utiliza para retornar un DS con la lista de los archivos soportados
    /// </summary>
    /// 
    public DataSet dsLista_archivos_soportados()
    {
        DataSet dsLista_archivos_soportados = new DataSet();
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            dsLista_archivos_soportados = wsVision2020.Lista_De_Archivos_Soportados();
        }
        catch (Exception ex)
        {
            return null;
        }
        return dsLista_archivos_soportados;
    }

    /// <summary>
    /// Método que se utiliza para retornar un DS con la lista de las carpetas
    /// Ejemplo: wsVision2020.Buscar_Carpetas("sisproap", "usersisproap", "Sistemas", "sisproap", "", "Dependencias|Region|Area|Sistema|Estacion|Equipo|Horimetro|Usuario Sistema");
    /// </summary>
    /// 
    private DataSet dsLista_Carpetas(string strLlaves, string strValoresLlaves)
    {
        DataSet dsBuscar_Carpetas = new DataSet();
        try
        {
            // Para el caso de sisproap siempre el strId_Gaveta = 0000003N
            wsVision2020 = new vision2020serverapionline.wsapi();
            dsBuscar_Carpetas = wsVision2020.Buscar_Carpetas(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strIdGaveta, strLlaves, strValoresLlaves);
        }

        catch (Exception ex)
        {
            throw ex;
        }
        return dsBuscar_Carpetas;
    }

    /// <summary>
    /// Método que se utiliza para retornar un DS con la lista de documentos de una carpeta
    /// Ejemplo: DataSet dsLista_De_Documentos = wsVision2020.Lista_De_Documentos(dsBuscar_Carpetas.Tables[0].Rows[0]["IDE_REG"].ToString());
    /// </summary>
    /// 
    private DataSet dsLista_Simple_Documentos_Carpeta(string strId_Carpeta)
    {
        DataSet dsLista_De_Documentos = new DataSet();
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            dsLista_De_Documentos = wsVision2020.Lista_De_Documentos(strId_Carpeta);
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return dsLista_De_Documentos;
    }

    /// <summary>
    /// Método que retorna un string con la URL de un id_objeto
    /// </summary>
    /// 
    public string strURLArchivo(string strID_Carpeta, string strIde_obj)
    {
        DataSet dsObtener_URLArchivo = new DataSet();
        string strURLArchivo = "";
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            strURLArchivo = wsVision2020.Descargar_Documento(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strID_Carpeta, strIde_obj, true);
        }
        catch (Exception ex)
        {
            return "";
        }
        return strURLArchivo;
    }

    /// <summary>
    /// Método que retorna un string con la descripción del archivo
    /// </summary>
    /// 
    public string strDescripcionArchivo(string strIde_obj)
    {
        DataSet dsObtener_DescripcionArchivo = new DataSet();
        string strDescripcionArchivo = "";
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            dsObtener_DescripcionArchivo = wsVision2020.Lista_Notas_Documento(const_strUsuario, const_strClave, strIde_obj);

            if (dsObtener_DescripcionArchivo.Tables.Count > 0)
            {
                strDescripcionArchivo = dsObtener_DescripcionArchivo.Tables[0].Rows[0]["Nota"].ToString();
            }
        }
        catch (Exception ex)
        {
            return "Sin descripción";
        }
        return strDescripcionArchivo;
    }

    /// <summary>
    /// Método que inserta una nota al documento
    /// </summary>
    /// 
    public bool bolInsertar_DescripcionArchivo(string strIde_carpeta, string strIde_objeto, string strDescripcion_obj)
    {
        bool Respuesta = false;
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            wsVision2020.Insertar_Nota_Documento(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strIde_carpeta, strIde_objeto, strDescripcion_obj);
            Respuesta = true;
        }

        catch (Exception ex)
        {
            return Respuesta;
        }
        return Respuesta;
    }

    /// <summary>
    /// Método que inserta una nota a la carpeta del riesgo, esto es para darle un nombre conocido a cada una de ellas
    /// </summary>
    /// 
    public bool bolInsertar_DescripcionCarpeta(string strArchivadores, string strIde_carpeta, string strDescripcion_obj)
    {
        bool Respuesta = false;
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            wsVision2020.Insertar_Nota_Expediente(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strIde_carpeta, strDescripcion_obj);
            Respuesta = true;
        }

        catch (Exception ex)
        {
            return Respuesta;
        }
        return Respuesta;
    }

    /// <summary>
    /// Este método devuelve un DS completo con la siguiente estructura (invoca los WebService necesarios) 
    ///--------------------------------------------------------------------------------------------------------------------- 
    ///  Dependencia | ide_reg | ide_obj | des_obj | archivado | MB | ext_tipo | URL | ESTADO 
    ///----------------------------------------------------------------------------------------------------------------------     
    /// </summary>
    /// <param name="strLlaves">estructura de la llave: ejemplo:"Dependencias|Region|Area|Sistema|Estacion|Equipo|Horimetro|Usuario Sistema"</param>
    /// <param name="strValoresLlaves">valores de la llave:ejemplo: 1|2|3|1|1|318|sisproap</param>
    /// <returns></returns>
    /// 
    public DataSet dsLista_Completa_Documentos_Carpeta(string strLlaves, string strValoresLlaves)
    {
        DataSet dsCarpeta = new DataSet();
        DataSet dsListaDocumentos = new DataSet();
        DataSet dsArchivo = new DataSet();
        try
        {
            // Obtener el id_reg (ID de la carpeta) y cantidad de documentos contenidos en ella
            dsCarpeta = dsLista_Carpetas(strLlaves, strValoresLlaves);

            if (dsCarpeta.Tables.Count.Equals(0))
            {
                // no existe una carpeta
            }

            else if (dsCarpeta.Tables[0].Rows.Count > 0)
            //PENDIENTE: ojo si encuentra mas de dos registros debe de enviar un correo al administrador indicando que encontró
            //directorios duplicados con la misma estructura y esto debe de correjirse.
            {
                // Obtiene la lista de los archivos (aun no tiene el URL)
                dsListaDocumentos = dsLista_Simple_Documentos_Carpeta(dsCarpeta.Tables[0].Rows[0]["ide_reg"].ToString());
                if (dsListaDocumentos.Tables.Count > 0)
                {
                    //Construir el DataTable
                    DataTable dtArchivo = new DataTable();
                    dtArchivo.Columns.Add("ide_carpeta", typeof(string));
                    dtArchivo.Columns.Add("ide_objeto", typeof(string));
                    dtArchivo.Columns.Add("des_objeto", typeof(string));
                    dtArchivo.Columns.Add("FechaArchivado", typeof(DateTime));
                    dtArchivo.Columns.Add("MB", typeof(string));
                    dtArchivo.Columns.Add("ext_objeto", typeof(string));
                    dtArchivo.Columns.Add("descripcion_objeto", typeof(string));
                    dtArchivo.Columns.Add("Estado", typeof(string));
                    //se recorre el DS para obtener la descripción del los archivos
                    foreach (DataRow drTemp in dsListaDocumentos.Tables[0].Rows)
                    {
                        //Cargar valores al ROW y agregar al DataTable
                        dtArchivo.Rows.Add(dsCarpeta.Tables[0].Rows[0]["ide_reg"].ToString(),
                                            drTemp["ide_obj"].ToString(),
                                            drTemp["des_obj"].ToString(),
                                            drTemp["Archivado"].ToString(),
                                            drTemp["MB"].ToString(),
                                            drTemp["ext_tip"].ToString(),
                                            strDescripcionArchivo(drTemp["ide_obj"].ToString()).ToString(),
                                            "~/App_Themes/Estados/imgBolita_Verde.png");
                    }
                    // Convertir el DataTable a DataSet
                    dsArchivo.Tables.Add(dtArchivo);
                }
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return dsArchivo;
    }

    /// <summary>
    /// Este método crea una carpeta, en la GAVETA="SEVRI"  Id_Gaveta="00000035"  
    /// </summary>
    /// 
    public string strInsertar_Carpeta(string strArchivadores, string strLlaves, string strValoresLlaves)
    {
        string strId_Carpeta = null;
        try
        {
            // Me aseguro que no exista esa carpeta o sea que no no se ha creado esa dependencia, ya que
            // aunque exista siempre ella crea una carpeta nueva, porque lo que importa es el ID y no el nombre de la dependencia
            // que trae en la llave
            wsVision2020 = new vision2020serverapionline.wsapi();
            if (!(wsVision2020.Existe_Carpeta(const_strArchivadores, const_strGaveta, strLlaves, strValoresLlaves)))
            {
                // Se crea la carpeta y se obtiene el id de la nueva carpeta
                strId_Carpeta = wsVision2020.Insertar_Carpeta(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strLlaves, strValoresLlaves);
            }
            else
            {
                // En el caso que si exista la carpeta, solo se solicita el id_carpeta invocando al método Id_Carpeta
                strId_Carpeta = Id_Carpeta(strLlaves, strValoresLlaves);
            }
        }
        catch (Exception ex)
        {

        }
        return strId_Carpeta;
    }

    /// <summary>
    /// Este método sube un archivo a una carpeta especifica, y agrega una descripción a al archivo, 
    /// En caso de no exisistir la carpeta, esta será creada automáticamente y se le agrega una etiqueta o nombre a dicha carpeta  
    /// </summary>
    /// 
    public bool Archivar_Documento_Byte(string strEtiquetaCarpeta, string strLlaves, string strValoresLlaves, string strNombreArchivo, Byte[] byteArchivoEnByte, string strDescripcionDocumento)
    {
        string strId_Carpeta = null;
        bool valor_retornado = false;
        string str_idObjeto = "";   //id del objeto luego de ser guardado
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            //Paso 1: asegurarse que la carpeta exista
            if (!(wsVision2020.Existe_Carpeta(const_strArchivadores, const_strGaveta, strLlaves, strValoresLlaves)))
            {
                // Se crea la carpeta y se obtiene el id de la nueva carpeta
                strId_Carpeta = wsVision2020.Insertar_Carpeta(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strLlaves, strValoresLlaves);
                // Se coloca una nota o etiqueta a la carpeta, esto es para personalizar el nombre, en este casa
                // se le esta asignando el codigo del riesgo.
                wsVision2020.Insertar_Nota_Expediente(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strId_Carpeta, strEtiquetaCarpeta);
            }
            else
            {
                // En el caso que si exista la carpeta, solo se solicita el id_carpeta invocando al método Id_Carpeta
                strId_Carpeta = Id_Carpeta(strLlaves, strValoresLlaves);
            }

            //Verificar si encontro el id_carpeta
            if (strId_Carpeta.ToString().Trim() != "")
            {
                //Paso 2: Archivar documento en Byte
                str_idObjeto = wsVision2020.ArchivarDocumentoByteDevuelveIdObjeto(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strId_Carpeta, strNombreArchivo, byteArchivoEnByte);
            }

            //Paso 3: Subir descripción del archivo (si es que existe) 
            if (!(strDescripcionDocumento.ToString() == string.Empty && str_idObjeto == string.Empty))
            {
                valor_retornado = bolInsertar_DescripcionArchivo(strId_Carpeta, str_idObjeto, strDescripcionDocumento);
            }
        }
        catch (Exception ex)
        {
            return valor_retornado;
        }
        return valor_retornado;
    }

    /// <summary>
    /// Carga el grid de documento
    /// </summary>
    /// <param name="lblTotalDocumento">cantidad de registros que posee el grid de documento</param>
    /// <param name="grvDocumento">grid para la carga de datos</param>
    /// <param name="strLlave">estructura de la llave - ejemplo: Dependencias|Region|Area|Sistema|Estacion|Equipo|Horimetro|Usuario Sistema</param>
    /// <param name="strLLavePK">valores de la llave - ejemplo: 1|2|3|1|1|318|sisproap</param>
    /// <returns></returns>
    /// 
    public Boolean LlenarGridView_Documento(Label lblTotalDocumento, GridView grvDocumento, String strLlave, String strLLavePK)
    {
        DataSet ListaArchivosDS = new DataSet();
        String strDependencia = String.Empty;
        try
        {
            if (strLLavePK.ToString() != "0")
            {

                //Se construye el campo con los valores de las llaves, se agrega el cambio de la biblioteca verificando si el 
                // se coloca la validacion, para verificar si la llave que ingresa es de Biblioteca o no
                //esto para mantener el PKDEPENDENCIA siempre en 1 para la llave biblioteca

                ListaArchivosDS = dsLista_Completa_Documentos_Carpeta(strLlave,
                (strLLavePK == (ConfigurationSettings.AppSettings["estructuraLlaveBiblioteca"] + "|" + ConfigurationManager.AppSettings["prmUsuario_VISION2020"].ToString()) ?
                ConfigurationSettings.AppSettings["PKBiblioteca"] : Session["PKDEPENDENCIA"].ToString().Trim()) + "|" +
               strLLavePK.ToString());
                if (ListaArchivosDS.Tables.Count.Equals(0))  //Si el DS viene vacio
                {
                    GlobalBL.InstanciaGlobalBL().sCantidadRegistros = "Documentos(0)";
                    lblTotalDocumento.Text = "0 Registros encontrados";
                }
                else
                {
                    Session["CANTIDAD"] = 0;
                    detalleGridView(ListaArchivosDS, grvDocumento, lblTotalDocumento);
                    Session["CANTIDAD"] = ListaArchivosDS.Tables[0].Rows.Count.ToString();
                    GlobalBL.InstanciaGlobalBL().sCantidadRegistros = "Documentos" + "(" + ListaArchivosDS.Tables[0].Rows.Count.ToString() + ")";
                }
            }
            return true;
        }
        catch (Exception ex)
        {
            return false; // no se logró conetar al web Service
        }
    }

    /// <summary>
    /// Guardar documentos en base a la llave establecida
    /// </summary>
    /// <param name="strEtiquetaCarpeta">descripcion de la carpeta, lo que se va almacenar</param>
    /// <param name="txtNombreDeseadoAchivo">Nombre del archivo</param>
    /// <param name="txtDescripcionDocumento">Descripcion del archivo</param>
    /// <param name="txtURL">Url: pendiente</param>
    /// <param name="afuArchivo">archivo a almacenar</param>
    /// <param name="strLlave">la estructura de la llave: ejemplo:"Dependencias|Region|Area|Sistema|Estacion|Equipo|Horimetro|Usuario Sistema"</param>
    /// <param name="strLLavePK">valores de la llave:ejemplo: 1|2|3|1|1|318|sisproap</param>
    /// TextBox txtURL-

    public void GuardarDatos_Documento(string strEtiquetaCarpeta, TextBox txtNombreDeseadoAchivo, TextBox txtDescripcionDocumento, TextBox txtURL,   AjaxControlToolkit.AsyncFileUpload afuArchivo, String strLlave, String strLLavePK)
    {
        Documento Archivar_documento = new Documento();
        Documento dtDocumento = new Documento();

        bool boolValorRetorno = false;

        //Ajustar nombre archivo, por si trae extensión
        if (txtNombreDeseadoAchivo.Text.ToString().Trim().IndexOf(".") > 0)
        {
            txtNombreDeseadoAchivo.Text = txtNombreDeseadoAchivo.Text.Remove(txtNombreDeseadoAchivo.Text.ToString().Trim().IndexOf("."),
             txtNombreDeseadoAchivo.Text.ToString().Trim().Length);
        }

        //Subir el archivo y descripción del archivo
        if (afuArchivo.HasFile)
        {
            boolValorRetorno = Archivar_documento.Archivar_Documento_Byte(
                strEtiquetaCarpeta,  //ConfigurationManager.AppSettings["prmGaveta_SISPROAP_VISION2020"],
                strLlave.ToString(), //"Dependencias|Region|Area|Sistema|Estacion|Equipo|Horimetro|Usuario Sistema"
                //Parámetro 2: construir valores de las llaves -------------------------------
                /* se coloca la validacion, para verificar si la llave que ingresa es de Biblioteca o no
               ,esto para mantener el PKDEPENDENCIA siempre en 1 para la llave biblioteca*/
                (strLLavePK == (ConfigurationSettings.AppSettings["estructuraLlaveBiblioteca"]) ?
                ConfigurationSettings.AppSettings["PKBiblioteca"] : Session["PKDEPENDENCIA"].ToString().Trim()) + "|" +
             strLLavePK.ToString(),
                //Fin contrucción parámetro llave ---------------------------------------------------
                //Parámetro 3: Nombre Archivo  
             txtNombreDeseadoAchivo.Text.ToString().Trim().Equals("") ? afuArchivo.FileName : (txtNombreDeseadoAchivo.Text.Trim() + ".pdf"),
                //Parámetro 4: Archivo en Byte
             afuArchivo.FileBytes,
                //Parámetro 6: Descripción del archivo
             txtDescripcionDocumento.Text);

            //PENDIENTE:Subir el archivo con el URL (ruta de INTERNET)
            // aqui implementar subir archivo cuando ponen la URL 
            txtNombreDeseadoAchivo.Text = "";
            txtDescripcionDocumento.Text = "";
            txtURL.Text = "";
        }
        txtNombreDeseadoAchivo.Focus();
    }

    /// <summary>
    /// Guarda en base de datos todo lo relacionado al archivo una vez que este fue subido al servidor 
    /// </summary>
    /// <param name="strValoresLlaves"> </param> ejemplo Cedula|Tipoadjunto se dividen con el siguiente caracter "|"
    /// <param name="strNombreArchivo"></param>  ejemplo 1-1044-0505|LISTACERTIFICACIONLITERAL
    /// <returns>Mensaje de el estado de la operacion</returns>
    public string Archivar_Documento(string strValoresLlaves, string strNombreArchivo, Byte[] byteArchivoEnByte)
    {
        string strId_Carpeta = null;
        string valor_retornado = "Error al guardar el archivo";
        try
        {
            wsVision2020 = new vision2020serverapionline.wsapi();
            //Paso 1: asegurarse que la carpeta exista
            if (!(wsVision2020.Existe_Carpeta(const_strArchivadores, const_strGaveta, const_strLlaves, strValoresLlaves)))
            {
                // Se crea la carpeta y se obtiene el id de la nueva carpeta
                strId_Carpeta = wsVision2020.Insertar_Carpeta(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, const_strLlaves, strValoresLlaves);
                // Se coloca una nota o etiqueta al carpeta, esto es para personalizar el nombre, en este casa
                // se le esta asignando el codigo del riesgo.
                //wsVision2020.Insertar_Nota_Expediente(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strId_Carpeta, strEtiquetaCarpeta);

            }
            else
            {

                // En el caso que si exista la carpeta, solo se solicita el id_carpeta invocando al método Id_Carpeta
                strId_Carpeta = Id_Carpeta(const_strLlaves, strValoresLlaves);
            }

            //Verificar si encontro el id_carpeta
            if (strId_Carpeta.ToString().Trim() != "")
            {
                //Paso 2: Archivar documento en Byte
                valor_retornado = wsVision2020.Archivar_DocumentoByte(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, const_strLlaves, strValoresLlaves, strNombreArchivo, byteArchivoEnByte);
            }
        }
        catch (Exception ex)
        {
            throw ex;
            //return valor_retornado;
        }
        return valor_retornado;
    }
    /// <summary>
    /// Este método devuelve la ruta html para ver un documento en especifico 
    /// </summary>
    public string Visor_Documento(string strValoresLlaves, string strCarpeta, string ruta, string strNombreDocumento)
    {
        wsVision2020 = new vision2020serverapionline.wsapi();
        string valor_retornado = "";
        string id_Carpeta = "";
        string id_Obj = "";
        DataSet ds = new DataSet();
        bool descargado = true;
        string strResultado = string.Empty;

        try
        {
            if (wsVision2020.Existe_Carpeta(const_strArchivadores, const_strGaveta, const_strLlaves, strValoresLlaves))
            {
                ds = wsVision2020.Buscar_Carpetas(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strIdGaveta, const_strLlaves, strValoresLlaves);
                id_Carpeta = ds.Tables[0].Rows[0]["ide_reg"].ToString();
                ds = wsVision2020.Lista_De_Documentos(id_Carpeta);
                if (ds.Tables[0].Rows.Count > 0)
                {
                    DateTime fecha = Convert.ToDateTime(ds.Tables[0].Rows[0]["Archivado"].ToString());
                    fecha = fecha.AddDays(-10);
                    foreach (DataRow row in ds.Tables[0].Rows)
                    {
                        if (Convert.ToDateTime(row["Archivado"].ToString()) >= fecha)
                        {

                            if (row["des_obj"].ToString().Replace(" ", "_") == strNombreDocumento.Replace(" ", "_"))
                            {
                                fecha = Convert.ToDateTime(row["Archivado"].ToString());
                                id_Obj = row["ide_obj"].ToString();
                            }
                        }
                    }
                    using (vision2020serverapionline.wsapi wsVision2020Descarga = new vision2020serverapionline.wsapi())
                    {
                        strResultado = wsVision2020Descarga.Descargar_Documento(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, id_Carpeta, id_Obj, true);
                        valor_retornado += GetFileName(strResultado.Replace(@"|", "")) + "|";
                        if (strResultado != string.Empty)
                            descargado = DescargarArchivo2020(strResultado, ruta, strCarpeta);

                    }

                }
                else
                {
                    return "No existe";
                }
            }
            else
            {
                return "No existe";
            }
        }
        catch (Exception ex)
        {
            return valor_retornado;
        }
        return valor_retornado;
    }
    private string GetFileName(string hrefLink)
    {
        string[] parts = hrefLink.Split('/');
        string fileName = "";

        if (parts.Length > 0)
            fileName = parts[parts.Length - 1];
        else
            fileName = hrefLink;

        return fileName;
    }
    private bool DescargarArchivo2020(string url, string ruta, string strCarpeta)
    {
        bool respuesta = false;
        try
        {
            WebRequest request = WebRequest.Create(url);
            WebResponse response = request.GetResponse();
            string targetUrl = ConfigurationManager.AppSettings["DocumentosPDF"].ToString() + @"\" + strCarpeta + @"\";// Server.MapPath("../../DocumentosPDF/" + strCarpeta + "/");
            //if (Directory.Exists(targetUrl))
            //{
            //    Directory.Delete(targetUrl,true);

            //}
            Directory.CreateDirectory(targetUrl);
            Directory.CreateDirectory(targetUrl + @"\DocumentosREQ\");

            string originalFileName = request.RequestUri.ToString().Substring(request.RequestUri.ToString().LastIndexOf("/") + 1);// response.ResponseUri.AbsolutePath.Substring(response.ResponseUri.AbsolutePath.LastIndexOf("/") + 1);
            Stream streamWithFileBody = response.GetResponseStream();

            using (Stream output = File.OpenWrite(ruta))
            {
                streamWithFileBody.CopyTo(output);
                streamWithFileBody.Close();
            }

            respuesta = true;
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return respuesta;
    }

    /// <summary>
    /// Este método devuelve la ruta html para ver un documento en especifico 
    /// </summary>
    public string Consultar_Documento(string strValoresLlaves, string strCarpeta, string strNombreDocumento)
    {
        wsVision2020 = new vision2020serverapionline.wsapi();
        string valor_retornado = "";
        string id_Carpeta = "";
        string id_Obj = "";
        DataSet ds = new DataSet();
        bool descargado = true;

        try
        {
            if (wsVision2020.Existe_Carpeta(const_strArchivadores, const_strGaveta, const_strLlaves, strValoresLlaves))
            {
                ds = wsVision2020.Buscar_Carpetas(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, strIdGaveta, const_strLlaves, strValoresLlaves);
                id_Carpeta = ds.Tables[0].Rows[0]["ide_reg"].ToString();
                ds = wsVision2020.Lista_De_Documentos(id_Carpeta);
                DateTime fecha = Convert.ToDateTime(ds.Tables[0].Rows[0]["Archivado"].ToString());
                fecha = fecha.AddDays(-10);
                int nTamanno = 0;
                foreach (DataRow row in ds.Tables[0].Rows)
                {
                    if (Convert.ToDateTime(row["Archivado"].ToString()) >= fecha)
                    {

                        if (row["des_obj"].ToString().Replace(" ", "_") == strNombreDocumento.Replace(" ", "_"))
                        {
                            id_Obj = row["ide_obj"].ToString();
                            fecha = Convert.ToDateTime(row["Archivado"].ToString());
                        }

                    }
                }
                using (vision2020serverapionline.wsapi wsVision2020Descarga = new vision2020serverapionline.wsapi())
                {
                    valor_retornado = wsVision2020Descarga.Descargar_Documento(const_strUsuario, const_strClave, const_strArchivadores, const_strGaveta, id_Carpeta, id_Obj, false);
                }

            }
            else
            {
                return "No existe";
            }
        }
        catch (Exception ex)
        {
            return valor_retornado;
        }
        return valor_retornado;
    }
}