示例#1
0
        public bool ActualizaProcesoAvance(ProcesoAvanceDto pdtoA, ProcesoDto pdto)
        {
            bool exito = false;

            try
            {
                if (ValidaAvanceDto(pdtoA) && ValidaDto(pdto))
                {
                    PrepareSp(SPACTUALIZAPROCESO);
                    CargaCmdParameter("UsuarioID", SqlDbType.Int, 8, ParameterDirection.Input, pdto.UsuarioID);
                    CargaCmdParameter("ProcesoID", SqlDbType.BigInt, 8, ParameterDirection.Input, pdto.ProcesoID);
                    CargaCmdParameter("Carga", SqlDbType.VarChar, 2, ParameterDirection.Input, pdtoA.Carga);
                    CargaCmdParameter("Descomprimir", SqlDbType.VarChar, 2, ParameterDirection.Input, pdtoA.Descomprimir);
                    CargaCmdParameter("Parseo", SqlDbType.VarChar, 2, ParameterDirection.Input, pdtoA.Parseo);
                    CargaCmdParameter("GenInfo", SqlDbType.VarChar, 2, ParameterDirection.Input, pdtoA.Getinfo);
                    CargaCmdParameter("Estatus", SqlDbType.VarChar, 10, ParameterDirection.Input, pdtoA.Estatus);
                    CargaCmdParameter("UltMensaje", SqlDbType.VarChar, 1000, ParameterDirection.Input, pdto.UltMensaje);
                    CargaCmdParameter("Observacion", SqlDbType.VarChar, 100, ParameterDirection.Input, pdtoA.Observacion);
                    ExecStoredProcNoQuery();
                    Close();
                }
                else
                {
                    EscribeLog("Proceso.ActualizaProcesoAvance " + msjerr + msjerravance);
                    return(false);
                }
            }
            catch (Exception Err) {
                EscribeLog("Proceso.GuardaProceso " + Err.Message.ToString());
            }
            return(exito);
        }
        public bool ProcesarDependenciasCM(ProcesoDto ProcDto, string Ruta)
        {
            bool        respuesta = false;
            ParseadorCM PCM       = new ParseadorCM();
            Proceso     proc      = new Proceso();

            try
            {
                if (validadatos(ProcDto.UsuarioID, ProcDto.ProcesoID, Ruta))
                {
                    string    Extensiones;
                    DataTable ExtensionesApp = proc.Consultas(1, ProcDto.AplicacionID);
                    if (ExtensionesApp == null || ExtensionesApp.Rows.Count < 1)
                    {
                        ErrLog.EscribeLogWS("No se encontraron los datos de lenguaje de la Aplicación");
                        ExtensionesApp = null;
                    }
                    else
                    {
                        DataRow Lenguaje = ExtensionesApp.Rows[0];
                        Extensiones = Lenguaje["Extensiones"].ToString();

                        string[]      extArray = Extensiones.ToLower().Split(',');
                        List <string> Archivos = new List <string>();

                        foreach (string Extension in extArray)
                        {
                            string   tipo          = "*." + Extension;
                            string[] ArchivosArray = Directory.GetFiles(Ruta, tipo, SearchOption.AllDirectories);
                            for (int i = 0; i <= ArchivosArray.Count() - 1; i++)
                            {
                                Archivos.Add(ArchivosArray[i].ToString());
                            }
                        }

                        HashSet <string> InventarioCM = new HashSet <string>();

                        foreach (string Archivo in Archivos)
                        {
                            InventarioCM = PCM.GenerarInventarioCM(Archivo, ProcDto);
                        }
                        ProcesoAvanceDto pdtoA = new ProcesoAvanceDto();
                        proc.SeteaAvance("En Proceso", "OK", "OK", "72", "70", "", "Inventario CM Generado", pdtoA, ProcDto);
                        proc.ActualizaProcesoAvance(pdtoA, ProcDto);

                        PCM.GenerarSalidaCM(InventarioCM, Archivos, ProcDto.AplicacionID.ToString(), ProcDto);
                        proc.SeteaAvance("Terminado", "OK", "OK", "OK", "OK", "", "Parseo Terminado", pdtoA, ProcDto);
                        proc.ActualizaProcesoAvance(pdtoA, ProcDto);
                        respuesta = true;
                    }
                }
            }
            catch (Exception Err)
            {
                ErrLog.EscribeLogWS("WSDependencias.ProcesaDependenciasCM " + Err.Message.ToString());
            }
            return(respuesta);
        }
        public void GenerarSalidaCM(HashSet <string> InventarioCM, List <string> Archivos, string App, ProcesoDto pdt)
        {
            ProcesoAvanceDto pdtoA  = new ProcesoAvanceDto();
            Proceso          proc   = new Proceso();
            double           total  = Archivos.Count();
            double           avance = 27 / total;

            for (int i = 0; i <= Archivos.Count() - 1; i++)
            {
                //Aquí van a ir los parametros para iniciar
                string      Ruta       = Archivos[i];
                string      Archivo    = Path.GetFileName(Ruta);
                int         NoLinea    = 0;
                RevisaLinea datosLinea = new RevisaLinea();

                //Empezar a leer el archivo
                using (StreamReader sr = new StreamReader(Ruta))
                {
                    while (sr.Peek() >= 0)
                    {
                        string lineaCodigo = sr.ReadLine().Trim();

                        //Contar No. Linea
                        ++NoLinea;

                        if (NoLinea == 1639)
                        {
                            NoLinea = NoLinea;
                        }

                        if (!String.IsNullOrEmpty(lineaCodigo))
                        {
                            //Actualizar el nuevo VerificaComentarios
                            lineaCodigo = VerCom.BuscarComentario(lineaCodigo);
                            if (!String.IsNullOrEmpty(lineaCodigo))
                            {
                                datosLinea.ObtenerSalida(lineaCodigo, Archivo, InventarioCM, Resultado, NoLinea, Ruta, Librerias);
                            }
                        }
                    }
                }
                proc.SeteaAvance("En Proceso", "OK", "OK", Math.Round((72 + avance * i), 0).ToString(), "70", "", "Recuperando Datos", pdtoA, pdt);
                proc.ActualizaProcesoAvance(pdtoA, pdt);
            }

            proc.SeteaAvance("En Proceso", "OK", "OK", "OK", "70", "", "Recuperando Datos", pdtoA, pdt);
            proc.ActualizaProcesoAvance(pdtoA, pdt);

            GuardaProcesoCM(pdtoA, pdt, Resultado);
            //System.IO.File.WriteAllLines(@"C:\INFONAVIT\ClasesMetodos.txt", Resultado);
        }
示例#4
0
        public bool GuardaProcesoCM(ProcesoAvanceDto pdtoA, ProcesoDto pdto, List <string> resultado)
        {
            bool   resp   = false;
            double total  = resultado.Count();
            double avance = 30 / total;

            try
            {
                int conta = 0;
                foreach (string res in resultado)
                {
                    string[] conceptos = res.Replace('\"', ' ').Split('|');
                    ConnexionPermanentePrepareSp(SPGGUARDARESULTADOCM);
                    if (conta == 0)
                    {
                        InicializaTran();
                    }
                    AsignaTran();
                    CargaCmdParameter("UsuarioID", SqlDbType.Int, 8, ParameterDirection.Input, pdto.UsuarioID);
                    CargaCmdParameter("ProcesoID", SqlDbType.Int, 8, ParameterDirection.Input, pdto.ProcesoID);
                    CargaCmdParameter("AplicacionID", SqlDbType.Int, 8, ParameterDirection.Input, pdto.AplicacionID);
                    CargaCmdParameter("NumLinea", SqlDbType.Int, 8, ParameterDirection.Input, int.Parse(conceptos[7]));
                    CargaCmdParameter("Referencia", SqlDbType.VarChar, 3000, ParameterDirection.Input, conceptos[11]);
                    CargaCmdParameter("NombreArchivo", SqlDbType.VarChar, 400, ParameterDirection.Input, conceptos[6]);
                    CargaCmdParameter("LenguajeApp", SqlDbType.VarChar, 10, ParameterDirection.Input, conceptos[8]);
                    CargaCmdParameter("BibPadre", SqlDbType.VarChar, 100, ParameterDirection.Input, conceptos[1]);
                    CargaCmdParameter("TipoPadre", SqlDbType.VarChar, 100, ParameterDirection.Input, conceptos[0]);
                    CargaCmdParameter("ObjPadre", SqlDbType.VarChar, 100, ParameterDirection.Input, conceptos[2]);
                    CargaCmdParameter("BibHijo", SqlDbType.VarChar, 100, ParameterDirection.Input, conceptos[4]);
                    CargaCmdParameter("TipoHijo", SqlDbType.VarChar, 100, ParameterDirection.Input, conceptos[3]);
                    CargaCmdParameter("ObjHijo", SqlDbType.VarChar, 100, ParameterDirection.Input, conceptos[5]);
                    CargaCmdParameter("DependenciaCMID", SqlDbType.Int, 8, ParameterDirection.Input, int.Parse(conceptos[9]));
                    CargaCmdParameter("IDPadre", SqlDbType.Int, 8, ParameterDirection.Input, int.Parse(conceptos[10]));
                    ++conta;
                    ExecStoredProcNoQuery();
                    SeteaAvance("En Proceso", "OK", "OK", "OK", Math.Round((70 + avance * conta), 0).ToString(), "", "Leyendo Archivos", pdtoA, pdto);
                }
                CommitTran();
                Close();
                ActualizaProcesoAvance(pdtoA, pdto);
            }
            catch (Exception Err)
            {
                EscribeLogWS("Guarda Resultado" + Err.Message.ToString());
                RollBackTran();
                Close();
                SeteaAvance("Error", "OK", "OK", "OK", "X", "Proceso terminado incorrectamente", Err.Message.ToString(), pdtoA, pdto);
                ActualizaProcesoAvance(pdtoA, pdto);
            }
            return(resp);
        }
示例#5
0
        private bool ValidaAvanceDto(ProcesoAvanceDto pdto)
        {
            bool valida = true;

            msjerr = "";
            try
            {
                if (pdto.ProcesoID <= 0)
                {
                    msjerravance = "UsuarioID incorrecto ";
                    valida       = false;
                }
                if (!(pdto.Carga.Equals("ok") || pdto.Carga.Equals("--") || pdto.Carga.Equals("x") || pdto.Carga.Equals("OK") || pdto.Carga.Equals("--") || pdto.Carga.Equals("X")))
                {
                    msjerravance += "Carga valor incorrecto debe ser ('ok', '--' ,'x') ";
                    valida        = false;
                }
                if (!(pdto.Descomprimir.Equals("ok") || pdto.Descomprimir.Equals("--") || pdto.Descomprimir.Equals("x") || pdto.Descomprimir.Equals("OK") || pdto.Descomprimir.Equals("--") || pdto.Descomprimir.Equals("X")))
                {
                    msjerravance += "Descomprimir valor incorrecto debe ser ('ok', '--' ,'x') ";
                    valida        = false;
                }
                if (!(pdto.Parseo.Equals("ok") || pdto.Parseo.Equals("--") || pdto.Parseo.Equals("x") || pdto.Parseo.Equals("OK") || pdto.Parseo.Equals("--") || pdto.Parseo.Equals("X")))
                {
                    if (!(int.Parse(pdto.Parseo) > 0 && int.Parse(pdto.Parseo) <= 100))
                    {
                        msjerravance += "Parseo valor incorrecto debe ser ('ok', '--' ,'x') ";
                        valida        = false;
                    }
                }
                if (!(pdto.Getinfo.Equals("ok") || pdto.Getinfo.Equals("--") || pdto.Getinfo.Equals("x") || pdto.Getinfo.Equals("OK") || pdto.Getinfo.Equals("--") || pdto.Getinfo.Equals("X")))
                {
                    if (!(int.Parse(pdto.Getinfo) >= 0 && int.Parse(pdto.Getinfo) <= 100))
                    {
                        msjerravance += "Getinfo valor incorrecto debe ser ('ok', '--' ,'x') ";
                        valida        = false;
                    }
                }
            }
            catch (Exception Err)
            {
                EscribeLog("Proceso.validaavancedto " + Err.Message.ToString());
                valida = false;
            }
            return(valida);
        }
        public HashSet <string> GenerarInventarioCM(string Ruta, ProcesoDto pdto)
        {
            RevisaLinea DatosInventario = new RevisaLinea();

            try
            {
                string Archivo = Path.GetFileName(Ruta);
                Archivo = Regex.Replace(Archivo, @"\.\w+", string.Empty).Trim();
                using (StreamReader sr = new StreamReader(Ruta))
                {
                    while (sr.Peek() >= 0)
                    {
                        string lineaCodigo = sr.ReadLine().Trim();

                        if (!String.IsNullOrEmpty(lineaCodigo))
                        {
                            //if (lineaCodigo.IndexOf("oWorkgroup") > -1)
                            //    lineaCodigo = lineaCodigo;

                            lineaCodigo = VerCom.BuscarComentario(lineaCodigo);
                            if (!String.IsNullOrEmpty(lineaCodigo))
                            {
                                DatosInventario = DatosInventario.ObtenerInventario(lineaCodigo, Librerias);
                                if (DatosInventario.EsValido)
                                {
                                    InventarioCM.Add((string.IsNullOrEmpty(DatosInventario.NombreEspacio) ?
                                                      Archivo : DatosInventario.NombreEspacio) + "|" + DatosInventario.Nombre +
                                                     "|" + DatosInventario.Tipo);
                                }
                            }
                        }
                    }
                }
            }catch (Exception Err) {
                EscribeLogWS("ParseadorCM.GenerarInventarioCM " + Err.Message.ToString());
                ProcesoAvanceDto pdtoA = new ProcesoAvanceDto();
                Proceso          proc  = new Proceso();
                proc.SeteaAvance("Error", "OK", "X", "--", "--", Err.Message.ToString(), "Error al realizar la descompresión del archivo", pdtoA, pdto);
                proc.ActualizaProcesoAvance(pdtoA, pdto);
            }
            return(InventarioCM);
        }
        public bool ProcesarDependenciasBD(ProcesoDto ProcDto, string Ruta, string csv)
        {
            bool             respuesta = false;
            ParseadorBD      PBD       = new ParseadorBD();
            ProcesoAvanceDto pdtoA     = new ProcesoAvanceDto();
            Proceso          proc      = new Proceso();

            try
            {
                if (validadatos(ProcDto.UsuarioID, ProcDto.ProcesoID, Ruta))
                {
                    PBD.pathsalida = csv;
                    PBD.GeneraSalida(ProcDto.AplicacionID, Ruta, ProcDto);
                    proc.SeteaAvance("En Proceso", "OK", "OK", "40", "40", "", "Parseo BD Terminado", pdtoA, ProcDto);
                    proc.ActualizaProcesoAvance(pdtoA, ProcDto);
                    respuesta = true;
                }
            }
            catch (Exception Err)
            {
                ErrLog.EscribeLogWS("WSBaseDatosWebService.ProcesaDependenciasBD " + Err.Message.ToString());
            }
            return(respuesta);
        }
        public bool ProcesarAplicacion(ProcesoDto ProcDto, string origen, string destino, string csv)
        {
            bool respuesta = false;

            try
            {
                EliminarParseo(ProcDto);
                if (Descomprimir(ProcDto, origen, destino))
                {
                    ProcesarDependenciasBD(ProcDto, destino, csv);
                    ProcesarDependenciasWS(ProcDto, destino);
                    ProcesarDependenciasCM(ProcDto, destino);
                }
            }
            catch (Exception Err)
            {
                Proceso          proceso = new Proceso();
                ProcesoAvanceDto pdtoA   = new ProcesoAvanceDto();
                proceso.SeteaAvance("En Proceso", "OK", "OK", "X", "X", "", "Parseo Fallido", pdtoA, ProcDto);
                proceso.ActualizaProcesoAvance(pdtoA, ProcDto);
                ErrLog.EscribeLogWS("WSDependencias.ProcesarAplicacion " + Err.Message.ToString());
            }
            return(respuesta);
        }
        //ConfigurationManager.AppSettings["pcsv"].ToString()
        public void GeneraSalida(int CveAplicacion, string Ruta, ProcesoDto pdto)
        {
            ControlLog         ErrLog   = new ControlLog();
            Entrada            Ent      = new Entrada();
            AplicacionDto      AppDto   = new AplicacionDto();
            ExcluyeComentarios ExcCom   = new ExcluyeComentarios();
            Procesos           Procesos = new Procesos();
            Salida             Salida   = new Salida();
            DataTable          configuracionDt;
            DataRow            configuracion;
            string             extensiones  = "";
            ProcesoAvanceDto   pdtoA        = new ProcesoAvanceDto();
            Proceso            proc         = new Proceso();
            string             TipoAnalisis = "BD";

            proc.SeteaAvance("En Proceso", "OK", "OK", "1", "--", "", "Iniciando Parseo BD", pdtoA, pdto);
            proc.ActualizaProcesoAvance(pdtoA, pdto);

            //Carga los datos de configuracion la ruta ya se trae, no se utiliza la de configuración
            using (configuracionDt = Consultas(1, CveAplicacion));
            {
                if (configuracionDt == null || configuracionDt.Rows.Count < 1)
                {
                    ErrLog.EscribeLogWS("No se encontraron los datos de configuración de la aplicación");
                    configuracion = null;
                }
                else
                {
                    configuracion = configuracionDt.Rows[0];
                }
            }

            //Determina que extensiones se deben leer deacuerdo al lenguaje
            DataTable LenguajeApp = ConsultaLenguaje(Convert.ToString(CveAplicacion));

            if (LenguajeApp == null || LenguajeApp.Rows.Count < 1)
            {
                ErrLog.EscribeLogWS("No se encontraron los datos de lenguaje de la Aplicación");
                LenguajeApp = null;
            }

            DataRow Lenguaje = LenguajeApp.Rows[0];

            //if (Lenguaje["Lenguaje"].ToString() == "ASP")
            extensiones = configuracion["Extensiones"].ToString();
            //else
            // extensiones = configuracion["ExtensionesJava"].ToString();

            String[] extArray = extensiones.ToLower().Split(',');


            //Validación
            if (String.IsNullOrEmpty(Convert.ToString(CveAplicacion)))
            {
                ErrLog.EscribeLogWS("No asigno la clave de la aplicación a analizar.");
                return;
            }

            //Obtiene todos los archivos de la ruta que deben leerse se cambio la ruta como parametro
            Ent.ListarArchivos(listaArchivos, Ruta, extArray, Convert.ToString(CveAplicacion));

            //Validación
            if (listaArchivos.Where(l => l.Extension == "java").Count() > 5)
            {
                AppDto.Tecnologia = "JAVA";
            }
            else if (listaArchivos.Where(l => l.Extension == "cs").Count() > 5)
            {
                AppDto.Tecnologia = "NET";
            }
            else if (listaArchivos.Where(l => l.Extension == "asp").Count() > 5)
            {
                AppDto.Tecnologia = "ASP";
            }
            else if (listaArchivos.Where(l => l.Extension == "sql").Count() > 5)
            {
                AppDto.Tecnologia = "Oracle";
            }
            else if (listaArchivos.Where(l => l.Extension == "frm").Count() > 5)
            {
                AppDto.Tecnologia = "Visual Basic 6";
            }

            AppDto.CveAplicacion = Convert.ToString(CveAplicacion);

            ////Obtiene lista de marcas de comentarios
            //Comentarios = Ent.CargarComentarios(configuracion["RutaComentarios"].ToString());
            //if (Comentarios == null || !Comentarios.Any())
            //{
            //    ErrLog.EscribeLogWS("El archivo de comentarios esta vacío");
            //    return;
            //}
            //ExcCom.Comentarios = Comentarios;
            //ErrLog.EscribeLogWS("El archivo de comentarios ha sido cargado.");

            //Carga las cadenas que no deben considerarse
            _CadenasAIgnorar = Ent.CargarAIgnorar();
            if (_CadenasAIgnorar == null || !_CadenasAIgnorar.Any())
            {
                ErrLog.EscribeLogWS("No se encontraron cadenas a Ignorar");
                return;
            }
            ErrLog.EscribeLogWS("Cargando cadenas a encontrar...");

            //Obtener las lineas que contienen palabras relacionadas con objetos de la BD
            if (TipoAnalisis == "BD")
            {
                _CadenasAEncontrar = Ent.CargarObjetosBD();
                if (_CadenasAEncontrar == null)
                {
                    ErrLog.EscribeLogWS("No hay cadenas a encontrar, verifique el inventario de objetos");
                    return;
                }
                ErrLog.EscribeLogWS("Las cadenas a encontrar han sido cargadas.");

                if (AppDto.Tecnologia == "NET" || AppDto.Tecnologia == "ASP")
                {
                    ConexionesBd = Ent.EncontrarConexionesNet();
                }

                if (AppDto.Tecnologia == "JAVA")
                {
                    ConexionesBd = Ent.EncontrarConexionesJava();
                }

                if (ConexionesBd == null || ConexionesBd.Count < 1)
                {
                    ErrLog.EscribeLogWS("Dentro de la aplicación no se encontraron conexiones a BD");
                }
                else
                {
                    ErrLog.EscribeLogWS("Se encontraron en la aplicación conexiones a BD");
                    ConexionesBd.ForEach(conexion =>
                    {
                        _CadenasAEncontrar.Add(new CadenaAEncontrarDto
                        {
                            Grupo        = conexion.BaseDatos,
                            NombreObjeto = conexion.Nombre,
                            TipoObjeto   = "ConexionBD",
                            TipoBusqueda = 0,
                            TipoObjetoID = 7
                        });
                    });
                    _CadenasAEncontrar = Procesos.ReordenarCadenas(_CadenasAEncontrar, ConexionesBd, AppDto);
                }
            }

            Ent.CargarCadenasDesdeBD(_CadenasAEncontrar, TipoAnalisis, AppDto);
            Parseador parser = new Parseador()
            {
                CadenasAIgnorar   = _CadenasAIgnorar,
                CadenasAEncontrar = _CadenasAEncontrar,
                RutaAnalisis      = Ruta,
                Comentarios       = Comentarios,
                ConexionesBd      = ConexionesBd
            };

            proc.SeteaAvance("En Proceso", "OK", "OK", "2", "--", "", "Guardando Datos", pdtoA, pdto);
            proc.ActualizaProcesoAvance(pdtoA, pdto);

            try
            {
                listaHallazgos = parser.ProcesarArchivos(listaArchivos, AppDto, pdto);
            }
            catch (Exception ex)
            {
                ErrLog.EscribeLogWS("Fallo el procesamiento de archivos: " + ex.Message + " " + ex.StackTrace);
                return;
            }
            StringBuilder csvSalida = new StringBuilder();

            try
            {
                csvSalida.AppendLine("AplicacionID" + separador + "ClaveAplicacion" + separador + "NumLinea" + separador + "Referencia" + separador + "ObjetoBDID" + separador +
                                     "Objeto" + separador + "TipoObjetoID" + separador + "TipoObjeto" + separador + "BaseDatosID" + separador + "BaseDatos" + separador + "Archivo" + separador
                                     + "Extension" + separador + "BibPadre" + separador + "ObjPadre");

                ErrLog.EscribeLogWS("Generando salida ...");

                List <string> resultado = new List <string>();
                resultado = Salida.GenerarSalida(separador, csvSalida, listaHallazgos);
                GuardaProcesoBD(pdtoA, pdto, resultado);
            }
            catch (Exception ex)
            {
                ErrLog.EscribeLogWS("Fallo en GenerarSalida " + ex.Message + " " + ex.StackTrace);
                return;
            }

            string rutaSalida = pathsalida + pdto.ProcesoID + ".csv";

            try
            {
                //Agregar la carga a la tabla
                File.WriteAllText(rutaSalida + "", csvSalida.ToString());
                ErrLog.EscribeLogWS("Salida CSV '" + rutaSalida + "' generada.");
            }
            catch (Exception ex)
            {
                ErrLog.EscribeLogWS("El archivo de salida CSV no pudo generarse: " + ex.Message);
                return;
            }
            finally
            {
                ErrLog.EscribeLogWS("Proceso terminado");
            }
        }
示例#10
0
        //Este metodo se encarga de comparar linea por linea del archivo con las cadenas
        //a encontrar e ignorar
        public List <ObjetoDto> ProcesarArchivos(List <ArchivoDto> listaArchivos, AplicacionDto AppDto, ProcesoDto pdto)
        {
            double           total  = listaArchivos.Count();
            double           avance = 38 / total;
            ProcesoAvanceDto pdtoA  = new ProcesoAvanceDto();
            Proceso          proc   = new Proceso();

            //if (AppDto.Tecnologia == "NET")
            //    EncontrarWsNet(listaArchivos);
            //else
            //    EncontrarWsJava(listaArchivos);

            int numArchivo = 1;

            Archivos = listaArchivos;

            foreach (ArchivoDto archivo in listaArchivos)
            //Parallel.ForEach(listaArchivos, archivo =>
            {
                ErrLog.EscribeLogWS("Procesando archivo: " + numArchivo + " de " + listaArchivos.Count + " " + archivo.Ruta);
                VerCom.ComentarioBloque = "";
                EncMet.Limpiar();

                using (StreamReader sr = new StreamReader(archivo.Ruta))
                {
                    NumLinea = 1;
                    while (sr.Peek() >= 0)
                    {
                        string lineaCodigo = sr.ReadLine().Trim();

                        if (!String.IsNullOrEmpty(lineaCodigo))
                        {
                            //lineaCodigo = ExcCom.BuscarComentario(lineaCodigo, archivo.Extension);
                            lineaCodigo = VerCom.BuscarComentario(lineaCodigo);
                            if (archivo.Extension == "cs" || archivo.Extension == "java")
                            {
                                ClaseMetodo = EncMet.EncuentraNombre(lineaCodigo);
                            }
                            else
                            {
                                ClaseMetodo = "";
                            }

                            if (!Excluir(lineaCodigo) && !string.IsNullOrEmpty(lineaCodigo))
                            {
                                ArchivoActual = archivo;

                                if (archivo.Extension == "aspx")
                                {
                                    if (lineaCodigo.ToLower().IndexOf("command") >= 0)
                                    {
                                        EncontrarCadena(lineaCodigo);
                                    }
                                }
                                else
                                {
                                    EncontrarCadena(lineaCodigo);
                                }
                            }
                        }
                        NumLinea++;
                    }
                }
                numArchivo++;
                proc.SeteaAvance("En Proceso", "OK", "OK", Math.Round(2 + (avance * numArchivo), 0).ToString(), "--", "", "Leyendo Archivos", pdtoA, pdto);
                proc.ActualizaProcesoAvance(pdtoA, pdto);
            }
            return(Objetos);
        }
示例#11
0
        public JsonResult IniciaCargaCSV(string Ruta, int UsuarioID)
        {
            ProcesoDto       ProDto       = new ProcesoDto();
            ControlLog       Log          = new ControlLog();
            ProcesoAvanceDto ProcADto     = new ProcesoAvanceDto();
            Proceso          Proc         = new Proceso();
            ObjetoDto        ObjDto       = new ObjetoDto();
            bool             respuesta    = false;
            bool             ValidaLayOut = true;
            int           DependenciaID   = 0;
            DataTable     DatosParseo;
            DataRow       DatoProceso;
            List <string> Resultado = new List <string>();

            try
            {
                using (TextFieldParser Lector = new TextFieldParser(Ruta))
                {
                    Lector.SetDelimiters(new string[] { "," });
                    Lector.HasFieldsEnclosedInQuotes = true;

                    //Lector.ReadLine();

                    string[] LayOut = new string[] { "AplicacionID", "ClaveAplicacion", "NumLinea", "Referencia", "ObjetoBDID", "Objeto", "TipoObjetoID", "TipoObjeto", "BaseDatosID", "BaseDatos", "Archivo", "Extension", "BibPadre", "ObjPadre" };

                    while (!Lector.EndOfData)
                    {
                        string[] LineaActual = Lector.ReadFields();
                        if (Lector.LineNumber == 2)
                        {
                            for (int i = 0; i < LineaActual.Length; i++)
                            {
                                if (LineaActual[i].ToString() != LayOut[i].ToString())
                                {
                                    ValidaLayOut = false;
                                }
                            }
                        }
                        else
                        {
                            if (ValidaLayOut)
                            {
                                ObjDto.CveAplicacion = LineaActual[1].ToString();
                                ObjDto.BibPadre      = LineaActual[12].ToString();
                                ObjDto.ObjPadre      = LineaActual[13].ToString();
                                ObjDto.BaseDatosID   = int.Parse(LineaActual[8]);
                                ObjDto.ObjetoID      = int.Parse(LineaActual[4]);
                                ObjDto.TipoID        = int.Parse(LineaActual[6]);
                                ObjDto.NumLinea      = int.Parse(LineaActual[2]);
                                ObjDto.Referencia    = LineaActual[3].ToString();
                                ObjDto.Archivo       = LineaActual[10].ToString();
                                ObjDto.Lenguaje      = LineaActual[11].ToString();

                                string Archivo = Path.GetFileName(ObjDto.Archivo);
                                Archivo             = Regex.Replace(Archivo, @"\.\w+", string.Empty).Trim();
                                ProDto.AplicacionID = int.Parse(ObjDto.CveAplicacion);
                                ++DependenciaID;
                                Resultado.Add(DependenciaID + "¡" + ObjDto.CveAplicacion + "¡" + (string.IsNullOrEmpty(ObjDto.BibPadre) ? Archivo : ObjDto.BibPadre) + "¡" + " " + "¡" + (string.IsNullOrEmpty(ObjDto.ObjPadre) ? Archivo : ObjDto.ObjPadre) + "¡" + ObjDto.BaseDatosID.ToString() + "¡" + ObjDto.ObjetoID.ToString() + "¡" + ObjDto.TipoID.ToString() + "¡" + ObjDto.NumLinea.ToString() + "¡" + ObjDto.Referencia + "¡" + ObjDto.Archivo + "¡" + ObjDto.Lenguaje);
                            }
                            else
                            {
                                Log.EscribeLog("LayOut incorrecto del archivo .csv.");
                                return(null);
                            }
                        }
                    }

                    if (Resultado.Count >= 1 && ProDto.AplicacionID > 0)
                    {
                        DatosParseo = Proc.ConsultaProceso(ProDto.AplicacionID);
                        if (DatosParseo.Rows.Count >= 1)
                        {
                            DatoProceso      = DatosParseo.Rows[0];
                            ProDto.UsuarioID = UsuarioID;
                            ProDto.ProcesoID = long.Parse(DatoProceso["ProcesoID"].ToString());

                            Proc.EliminarParseo(ProDto, 0);
                            Proc.GuardaProcesoBD(ProcADto, ProDto, Resultado);
                        }
                        else
                        {
                            Log.EscribeLog("No se realizo la carga completa del archivo .csv");
                            DatosParseo = null;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.EscribeLog("No existe un ProcesoID cargado. No es posible cargar el archivo " + Path.GetFileName(Ruta));
                return(null);
            }

            return(Json(respuesta, JsonRequestBehavior.AllowGet));
        }
示例#12
0
 public void SeteaAvance(string estatus, string carga, string descomprimir, string parseo, string getinfo, string umsj, string obs, ProcesoAvanceDto pdtoA, ProcesoDto pdto)
 {
     pdtoA.ProcesoID    = pdto.ProcesoID;
     pdtoA.Carga        = carga;
     pdtoA.Descomprimir = descomprimir;
     pdtoA.Parseo       = parseo;
     pdtoA.Getinfo      = getinfo;
     pdto.UltMensaje    = umsj;
     pdtoA.Observacion  = obs;
     pdtoA.Estatus      = estatus;
 }
        public HashSet <string> GenerarInventarioWS(string Ruta, ProcesoDto pdto, string Tipo)
        {
            try
            {
                using (StreamReader sr = new StreamReader(Ruta))
                {
                    IntDto.Nombre     = string.Empty;
                    IntDto.IP         = string.Empty;
                    IntDto.Middleware = string.Empty;
                    while (sr.Peek() >= 0)
                    {
                        string LineaCodigo = sr.ReadLine().Trim();

                        //if (LineaCodigo.IndexOf("http://www.presidencia.gob.mx") > -1)
                        //    LineaCodigo = LineaCodigo;

                        if (!String.IsNullOrEmpty(LineaCodigo))
                        {
                            // Los datos para los servicios de C# se encuentran dentro de la misma línea
                            if (Tipo.IndexOf("config") > -1)
                            {
                                IntDto = RI.ObtenerInventario(LineaCodigo, pdto);
                                if (!string.IsNullOrEmpty(IntDto.Nombre) && !string.IsNullOrEmpty(IntDto.IP))
                                {
                                    InventarioWS.Add(IntDto.Nombre + "|" + IntDto.IP + "|" + IntDto.Tipo + "|" + IntDto.Middleware);
                                }
                            }

                            // Los datos para los servicios de C# se encuentran dentro de la misma línea
                            if (Tipo.IndexOf("asp") > -1)
                            {
                                IntDto = RI.ObtenerInventario(LineaCodigo, pdto);
                                if (!string.IsNullOrEmpty(IntDto.Nombre) && !string.IsNullOrEmpty(IntDto.IP))
                                {
                                    InventarioWS.Add(IntDto.Nombre + "|" + IntDto.IP + "|" + IntDto.Tipo + "|" + IntDto.Middleware);
                                }
                            }

                            //Los datos para los servicios Java se encuentran en varias líneas
                            if (Tipo.IndexOf("wsdl") > -1)
                            {
                                //string Linea = LineaCodigo.ToLower();
                                Regex Regex = new Regex(@"service name=""\w+");
                                Match Match = Regex.Match(LineaCodigo);
                                if (Match.Success)
                                {
                                    string Nombre = Regex.Replace(Match.Value, @"service name=", string.Empty);
                                    Nombre        = Nombre.Replace(@"""", string.Empty).Replace("Service", string.Empty);
                                    IntDto.Nombre = Nombre.Trim();
                                }

                                Regex = new Regex(@"\bhttp://\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\S+\b");
                                Match = Regex.Match(LineaCodigo);
                                if (Match.Success)
                                {
                                    string IP = Match.Value;
                                    IntDto.IP = IP.Trim();
                                }

                                if (!string.IsNullOrEmpty(IntDto.IP))
                                {
                                    if (ObtenMiddleware(pdto.UsuarioID))
                                    {
                                        XmlDocument consultaxml = PAvanceXML;
                                        foreach (XmlNode Fila in consultaxml.DocumentElement.SelectSingleNode("Middleware").SelectNodes("row"))
                                        {
                                            if (IntDto.IP.IndexOf(Fila.Attributes["IP"].Value.ToString()) > -1)
                                            {
                                                IntDto.Middleware = Fila.Attributes["Middleware"].Value.ToString();
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    if (!string.IsNullOrEmpty(IntDto.Nombre) && !string.IsNullOrEmpty(IntDto.IP))
                    {
                        InventarioWS.Add(IntDto.Nombre + "|" + IntDto.IP + "|" + IntDto.Tipo + "|" + IntDto.Middleware);
                    }
                }
            }
            catch (Exception Err)
            {
                EscribeLogWS("ParseadorWS.GenerarInventarioWS " + Err.Message.ToString());
                ProcesoAvanceDto pdtoA = new ProcesoAvanceDto();
                Proceso          proc  = new Proceso();
                proc.SeteaAvance("Error", "OK", "X", "--", "--", Err.Message.ToString(), "Error al realizar la descompresión del archivo", pdtoA, pdto);
                proc.ActualizaProcesoAvance(pdtoA, pdto);
            }
            return(InventarioWS);
        }
        public bool ProcesarDependenciasWS(ProcesoDto ProcDto, string Ruta)
        {
            bool             respuesta = false;
            ParseadorWS      PWS       = new ParseadorWS();
            ProcesoAvanceDto pdtoA     = new ProcesoAvanceDto();
            Proceso          proc      = new Proceso();

            try
            {
                if (validadatos(ProcDto.UsuarioID, ProcDto.ProcesoID, Ruta))
                {
                    DataTable LenguajeApp = proc.ConsultaLenguaje(Convert.ToString(ProcDto.AplicacionID));
                    if (LenguajeApp == null || LenguajeApp.Rows.Count < 1)
                    {
                        ErrLog.EscribeLogWS("No se encontraron los datos de lenguaje de la Aplicación");
                        LenguajeApp = null;
                    }
                    else
                    {
                        DataRow Lenguaje = LenguajeApp.Rows[0];
                        string  Tipo     = Lenguaje["Extension"].ToString();
                        if (Tipo == "cs")
                        {
                            Tipo = "*.config";
                        }
                        else if (Tipo == "java")
                        {
                            Tipo = "*.wsdl";
                        }
                        else if (Tipo == "asp")
                        {
                            Tipo = "*.asp";
                        }

                        string[] Archivos = Directory.GetFiles(Ruta, Tipo, SearchOption.AllDirectories);

                        HashSet <string> InventarioWS = new HashSet <string>();

                        proc.SeteaAvance("En Proceso", "OK", "OK", "40", "40", "", "Iniciando Parseo WS", pdtoA, ProcDto);
                        proc.ActualizaProcesoAvance(pdtoA, ProcDto);

                        for (int i = 0; i <= Archivos.Count() - 1; i++)
                        {
                            InventarioWS = PWS.GenerarInventarioWS(Archivos[i], ProcDto, Tipo);
                        }

                        proc.SeteaAvance("En Proceso", "OK", "OK", "42", "40", "", "Inventario de WS Generado", pdtoA, ProcDto);
                        proc.ActualizaProcesoAvance(pdtoA, ProcDto);

                        Tipo     = "*." + Lenguaje["Extension"].ToString();
                        Archivos = Directory.GetFiles(Ruta, Tipo, SearchOption.AllDirectories);

                        PWS.GenerarSalidaWS(InventarioWS, Archivos, ProcDto.AplicacionID.ToString(), ProcDto);
                        proc.SeteaAvance("En Proceso", "OK", "OK", "70", "70", "", "Parseo WS Terminado", pdtoA, ProcDto);
                        proc.ActualizaProcesoAvance(pdtoA, ProcDto);
                        respuesta = true;
                    }
                }
            }
            catch (Exception Err)
            {
                ErrLog.EscribeLogWS("WSInterfacesWebService.ProcesaDependenciasWS " + Err.Message.ToString());
            }
            return(respuesta);
        }