private void ProcurarArquivos(string caminho, string parametro)
        {
            try
            {
                DirectoryInfo directoryInfo = new DirectoryInfo(caminho);
                FileInfo[]    files         = directoryInfo.GetFiles();

                int atual = 0;
                int total = files.Count();

                string        caminhoArquivo = string.Empty;
                StringBuilder sb;

                List <string> linhas;
                string        linhaAlterada;

                foreach (var file in files)
                {
                    atual++;
                    caminhoArquivo = file.FullName;

                    Utilitarios.GeradorArquivo geradorArquivo = new Utilitarios.GeradorArquivo(caminhoArquivo);
                    sb = geradorArquivo.LerArquivoTextoStringBuilder();

                    linhas        = TransformarEmLista(sb.ToString());
                    linhaAlterada = string.Empty;

                    foreach (var linha in linhas)
                    {
                        if (linha.ToUpper().Contains(parametro.ToUpper()))
                        {
                            //linhasEncontradas.Add(new ArquivoEncontrado(linha.Trim(), file.Name, linhas.IndexOf(linha) + 1, Path.GetExtension($"{caminho}\\{file}")));
                            dtgArquivos.Rows.Add(file.Name, linhas.IndexOf(linha) + 1, Path.GetExtension($"{caminho}\\{file}"), linha.Trim(), $"{caminho}\\{file}", VerificarDePara(linha.ToUpper(), out string tabela), tabela);
                        }
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }

            string VerificarDePara(string linha, out string tabela)
            {
                switch (VerificarContains(linha, out tabela))
                {
                case "ITEM": return("ITEM -> BHS.MERCADORIA");

                case "VESSEL_DETAILS": return("VESSEL_DETAILS -> BHS.ESCALA");

                case "VESSELDETAILS": return("VESSEL_DETAILS -> BHS.ESCALA");

                case "VESVOYAGE": return("VES_VOYAGE -> BHS.ESCALA");

                case "VES_VOYAGE": return("VES_VOYAGE -> BHS.ESCALA");

                case "VESSEL": return("VESSEL -> BHS.NAVIO");

                case "ITEM_REEFER": return("ITEM_REEFER -> BHS.MERCADORIA");

                case "ITEM_SEAL": return("ITEM_SEAL -> BHS.AMR_LACRE_MERCADORIA");

                case "ITEMSEAL": return("ITEM_SEAL -> BHS.AMR_LACRE_MERCADORIA");

                case "ITEM_OOG": return("ITEM_OOG -> BHS.EXCESSO");

                case "ITEMOOG": return("ITEM_OOG -> BHS.EXCESSO");

                case "ITEM_LOCATION": return("ITEM_LOCATION -> BHS.AMR_LOCALIZACAO_MERCADORIA");

                case "ITEMLOCATION": return("ITEM_LOCATION -> BHS.AMR_LOCALIZACAO_MERCADORIA");

                case "BOOKINGS": return("BOOKINGS -> BHS.BOOKING + BHS.ITEM_BOOKING");

                case "PORTCODE": return("PORTCODE -> BHS.PORTO");

                case "DAMAGE_CODE": return("DAMAGE_CODE -> BHS.TIPO_AVARIA");

                case "CHE_MASTER": return("CHE_MASTER -> BHS.EQUIPAMENTOS");

                case "STOP_CODE": return("STOP_CODE -> BHS.BLOQUEIO");

                case "SEAL_TYPE": return("SEAL_TYPE -> BHS.TIPO_LACRE");

                case "VIEW_VES_SCHEDULE": return("VIEW_VES_SCHEDULE -> BHS.ESCALA");

                case "VES_SERVICE": return("VES_SERVICE -> BHS.SERVICOS_NAVIO");

                case "CUSTOMER": return("CUSTOMER -> ACCESSCONTROL.LOCAL_PARCEIRO");

                case "ISO_CODE": return("ISO_CODE -> BHS.ISO_CODE");

                case "HAZ_MASTER": return("HAZ_MASTER -> BHS.IMO");

                case "OPERATOR": return("OPERATOR -> ACCESSCONTROL.USUARIO");

                case "DISCHARGE_LIST": return("DISCHARGE_LIST -> BHS.VW_MERCADORIA");

                case "VW_ESCALA": return("VW_ESCALA -> BHS.ESCALA");

                case "DISCH_DANGEROUS": return("DISCH_DANGEROUS -> BHS.AMR_IMO_MERCADORIA");

                case "DISCH_REEFER": return("DISCH_REEFER -> BHS.MERCADORIA");

                case "DISCH_OOG": return("DISCH_OOG -> BHS.EXCESSO");

                case "BOOKING_DANGEROUS": return("BOOKING_DANGEROUS -> BHS.ITEM_BOOKING");

                case "ITEM_STOPS": return("ITEM_STOPS -> BHS.AMR_BLOQUEIO_MERCADORIA + BHS.BLOQUEIO");

                case "REEFER_MONITOR": return("REEFER_MONITOR -> BHS.MONITORAMENTO_REFER");

                default: return("");
                }
            }

            string VerificarContains(string linha, out string tabela)
            {
                var tabelasTops = new List <string>
                {
                    "VESVOYAGE",
                    "VES_VOYAGE",
                    "BOOKINGS",
                    "ITEM_REEFER",
                    "ITEM_SEAL",
                    "ITEMSEAL",
                    "ITEM_LOCATION",
                    "ITEMLOCATION",
                    "ITEM_OOG",
                    "ITEMOOG",
                    "ITEM",
                    "VESSEL_DETAILS",
                    "ITEM_REEFER",
                    "VESSEL",
                    "PORTCODE",
                    "DAMAGE_CODE",
                    "CHE_MASTER",
                    "STOP_CODE",
                    "SEAL_TYPE",
                    "VIEW_VES_SCHEDULE",
                    "VES_SERVICE",
                    "CUSTOMER",
                    "ISO_CODE",
                    "HAZ_MASTER",
                    "OPERATOR",
                    "DISCHARGE_LIST",
                    "VW_ESCALA",
                    "DISCH_DANGEROUS",
                    "DISCH_REEFER",
                    "DISCH_OOG",
                    "BOOKING_DANGEROUS",
                    "ITEM_STOPS"
                };

                foreach (var tabelaTops in tabelasTops)
                {
                    if (linha.Contains(tabelaTops))
                    {
                        tabela = tabelaTops;
                        return(tabelaTops);
                    }
                }

                tabela = string.Empty;
                return("");
            }
        }
Esempio n. 2
0
        private void ProcurarArquivos(string caminho, string parametro, DateTime?dataInicial, DateTime?dataFinal, bool regex, bool novoFormato, bool antigoFormato)
        {
            try
            {
                DirectoryInfo directoryInfo = new DirectoryInfo(caminho);
                FileInfo[]    files         = (dataInicial.HasValue && dataFinal.HasValue) ? directoryInfo.GetFiles().Where(p => p.LastWriteTimeUtc >= dataInicial && p.LastWriteTimeUtc <= dataFinal).ToArray() : directoryInfo.GetFiles();

                int atual = 0;
                int total = files.Count();

                string        caminhoArquivo = string.Empty;
                StringBuilder sb;

                List <string> linhas;
                string        linhaAlterada;

                foreach (var file in files)
                {
                    atual++;
                    caminhoArquivo = file.FullName;

                    Utilitarios.GeradorArquivo geradorArquivo = new Utilitarios.GeradorArquivo(caminhoArquivo);
                    sb = geradorArquivo.LerArquivoTextoStringBuilder();

                    linhas        = TransformarEmLista(sb.ToString());
                    linhaAlterada = string.Empty;

                    if (!string.IsNullOrWhiteSpace(parametro))
                    {
                        if (regex)
                        {
                            foreach (string linha in linhas)
                            {
                                if (linhas.Count > 1)
                                {
                                    linhaAlterada = linha + "\'";
                                }
                                if (Regex.IsMatch(linhaAlterada, @parametro))
                                {
                                    PreencherLista(file);
                                    break;
                                }
                            }
                        }
                        else
                        {
                            if (sb.ToString().Contains(parametro))
                            {
                                PreencherLista(file);
                            }
                        }
                    }
                    else if (novoFormato)
                    {
                        if (VerificarFormato(linhas, true))
                        {
                            PreencherLista(file);
                        }
                    }
                    else if (antigoFormato)
                    {
                        if (VerificarFormato(linhas, false))
                        {
                            PreencherLista(file);
                        }
                    }
                    else
                    {
                        PreencherLista(file);
                    }

                    PreencherStatus(total, atual);
                    Application.DoEvents();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        private void ProcurarArquivos(string caminho, string parametro, DateTime?dataInicial, DateTime?dataFinal, bool regex, bool novoFormato, bool antigoFormato, bool multiplosParametros)
        {
            try
            {
                DirectoryInfo directoryInfo = new DirectoryInfo(caminho);
                FileInfo[]    files         = (dataInicial.HasValue && dataFinal.HasValue) ?
                                              directoryInfo.GetFiles().Where(p => p.LastWriteTimeUtc >= dataInicial && p.LastWriteTimeUtc <= dataFinal).ToArray() :
                                              directoryInfo.GetFiles().ToArray();

                int atual = 0;
                int total = files.Count();

                string        caminhoArquivo = string.Empty;
                StringBuilder sb;

                List <string> linhas;
                string        linhaAlterada;
                string[]      parametros = null;
                if (multiplosParametros)
                {
                    parametros = parametro.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
                }

                bool achou;
                foreach (var file in files)
                {
                    achou = false;
                    atual++;
                    caminhoArquivo = file.FullName;

                    Utilitarios.GeradorArquivo geradorArquivo = new Utilitarios.GeradorArquivo(caminhoArquivo);
                    sb = geradorArquivo.LerArquivoTextoStringBuilder();

                    linhas        = TransformarEmLista(sb.ToString());
                    linhaAlterada = string.Empty;

                    if (!string.IsNullOrWhiteSpace(parametro))
                    {
                        if (regex)
                        {
                            foreach (string linha in linhas)
                            {
                                if (linhas.Count > 1)
                                {
                                    linhaAlterada = linha + "\'";
                                }
                                if (Regex.IsMatch(linhaAlterada, @parametro))
                                {
                                    PreencherLista(file);
                                    break;
                                }
                            }
                        }
                        else
                        {
                            if (multiplosParametros && parametros != null && parametros.Count() > 1)
                            {
                                achou = parametros.Any(p => sb.ToString().Contains(p));
                            }
                            else
                            {
                                achou = sb.ToString().Contains(parametro);
                            }

                            if (achou)
                            {
                                PreencherLista(file);
                            }
                        }
                    }
                    else if (novoFormato)
                    {
                        if (VerificarFormato(linhas, true))
                        {
                            PreencherLista(file);
                        }
                    }
                    else if (antigoFormato)
                    {
                        if (VerificarFormato(linhas, false))
                        {
                            PreencherLista(file);
                        }
                    }
                    else
                    {
                        PreencherLista(file);
                    }

                    PreencherStatus(total, atual);
                }

                AtualizarEstadoPesquisa("Finalizada.");
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                pesquisando = false;
            }
        }