none
Copiar um diretorio que está em um ftp e todo seu conteudo para a maquina local. RRS feed

  • Discussão Geral

  • Pessoal boa noite,

    Estou iniciando em C# e estou tentando criar um instalar para uma aplicação onde nada é instalado, esta aplicação é em Visual basic 6.

    O que preciso é que o instalador acesse um endereço de ftp, copie um diretorio e todo o seu conteudo para a maquina local do usuario que vai utilizar a aplicação.

    O que já consegui fazer em C# foi criar o diretorio na maquina onde todo este conteudo vindo do ftp será copiado.

    alguem pode ajudar ?


    Fabio Aragao

    segunda-feira, 31 de julho de 2017 19:55

Todas as Respostas

  • Olá.

    O que você pretende é ler pelo windows ou pelo FTP.

    Porque se for pelo FTP, voce precisa fazer o download.

    Se voce for ler pelo windows, você pode ler os arquivos do Folder e copiar um por vez.

    responda ai que tento te ajudar.

    att.

    terça-feira, 1 de agosto de 2017 17:54
  • Obrigado por responder...

    A aplicação em C# é que vai fazer o trabalho.


    Fabio Aragao

    terça-feira, 1 de agosto de 2017 18:01
  • Olá. Desculpe.

    Eu que criei a confusão. Voce disse que quer acessar por FTP no seu post.

    vou colocar abaixo o exemplo. Existe um metodo que pega a lista de arquivos do FTP, ai é só baixar um por um.

    a rotina está abaixo, é meio extensa. Eu comentei umas linhas onde eu gravou logs do que ocorreu.

    Eu te passei uma classe completa que cria a conexão FTP. 

    Espero que te ajude.

    	//  R E G R A S     D E     R E C E B I M E N T O 
    
    		#region recebimento ARQUIVOS
    
            Dictionary<string, string> _filesInFolder = null;
    
    		string nomePastaDownload = PASTA_ORIGEM_ARQ.Replace("\\", "/");
    		if (nomePastaDownload.Length > 0)
    		{
    			if (nomePastaDownload.Substring(nomePastaDownload.Length - 1) != "/")
    				nomePastaDownload += "/";
    		}
    
    		string nomePastaBackup = PASTA_BACKUP_ARQ.Replace("\\", "/");
    		if (nomePastaBackup.Length > 0)
    		{
    			if (nomePastaBackup.Substring(nomePastaBackup.Length - 1) != "/")
    				nomePastaBackup += "/";
    		}
    
    		contadorExecucao = 0;
    
    		string userName = FTP_USUARIO;
    		string passWord = FTP_SENHA_USUARIO;
    
    		while (contadorExecucao < 3)
    		{
    			try
    			{
    				contadorExecucao++;
    
    				FTPConnection FTP = new FTPConnection(ftpDestino.ToLower().Replace("ftp://", "").Replace("\\", "/"), userName, passWord);
    
    				// Cria o diretorio se não existir  (atenção: PastaDestinoRemoto aqui é o diretorio porque está recebendo)
    				System.IO.DirectoryInfo dirInfo = new DirectoryInfo(PASTA_DESTINO_ARQ);
    				if (!dirInfo.Exists)
    				{
    					// Cria o diretorio para geração do xml
    					try
    					{
    						dirInfo.Create();
    					}
    					catch (Exception)
    					{
    						//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Não foi possível criar o diretório retorno " + PASTA_DESTINO_ARQ);
    					}
    					finally
    					{
    						dirInfo = null;
    					}
    				}
    
    				pastaDestinoLocal = PASTA_DESTINO_ARQ;
    
    				nomeFolderAux = string.Empty;
    
    				pastaOrigemRemoto = System.IO.Path.Combine(ftpDestino, PASTA_ORIGEM_ARQ).Replace("\\", "/");
    				pastaDestinoLocal = PASTA_DESTINO_ARQ;
    
    				_filesInFolder = FTP.GetFileList(ftpDestino, @PASTA_ORIGEM_ARQ.Replace("\\", "/"),
    					string.Empty, true, Empresa.Configuracoes[i_emp].FTP_UTLIZAPROXY);
    
    				if (_filesInFolder != null)
    				{
    					foreach (string key in _filesInFolder.Keys)
    					{
    						if (key.IndexOf('.') != -1)
    						{
    							arquivoTxt = Path.GetFileName(_filesInFolder[key].ToString());
    							if (
    								(INICIAL_ARQUIVO == "*.*")
    								||
    								arquivoTxt.Substring(0, INICIAL_ARQUIVO.Length).ToLower() ==
    								INICIAL_ARQUIVO.ToLower()
    								|| ((((INICIAL_ARQUIVO.Length > 1) &&
    									INICIAL_ARQUIVO.Substring(0, 2) == "*.")
    									&& INICIAL_ARQUIVO.Length == 5)
    									&& INICIAL_ARQUIVO.Substring(1, 4).ToUpper() ==
    									Path.GetExtension(arquivoTxt).ToUpper()
    									)
    							   )
    							{
    								//bool download = false;
    								try
    								{
    									nomeFolderAux = System.IO.Path.Combine(ftpDestino, @PASTA_BACKUP_ARQ).Replace("\\", "/");
    									string targetPathStr = Path.Combine(pastaDestinoLocal, arquivoTxt).Replace("/", "\\");
    									nomeFolderAux = Path.Combine(nomeFolderAux, arquivoTxt).Replace("\\", "/");
    
    									resultado = string.Empty;
    									Logger.Log(TipoLog.Info, TipoLogSource.Service, "Iniciando o download arquivo: " + arquivoTxt + contadorExecucao.ToString() + "a tentativa.");
    
    									FTP.DownloadFileFromFtp(ftpDestino, @PASTA_ORIGEM_ARQ.Replace("\\", "/"), arquivoTxt,
    										targetPathStr, Empresa.Configuracoes[i_emp].FTP_UTLIZAPROXY);
    
    									Logger.Log(TipoLog.Info, TipoLogSource.Service, "Download arquivo: " + arquivoTxt + " realizado com sucesso.");
    									//download = true;
    
    									targetPathStr = Path.Combine(@PASTA_DESTINO_ARQ, arquivoTxt);
    
    									if (System.IO.File.Exists(targetPathStr))
    									{
    										try
    										{
    											// Nome arquivo origem pra renomear
    											targetPathStr = _filesInFolder[key].ToString().Replace(ftpDestino, "");
    											// Nome do arquivo de destino backup
    											nomeFolderAux = nomeFolderAux.Replace(ftpDestino, "");
    											bool finaliza = false;
    											int contadorexecucao1 = 0;
    											while (!finaliza)
    											{
    												contadorexecucao1++;
    												//verifica se o arquivos existem na pasta de backup e cria novo nome para ele se existir
    												try
    												{
    													//string struxir = nomePastaBackup.Substring(nomeFolderAux.Split('/')[0].Length + 1);
    													_filesInFolder2 = FTP.GetFileList(ftpDestino, @PASTA_BACKUP_ARQ.Replace("\\", "/"),
    													Path.GetFileName(nomeFolderAux).Replace("\\", "/") + hora, false, Empresa.Configuracoes[i_emp].FTP_UTLIZAPROXY);
    												}
    												catch
    												{
    													_filesInFolder2 = null;
    												}
    
    												if (_filesInFolder2 == null)
    												{
    													string caminhoOrigem = string.Empty, caminhoDestino = string.Empty;
    
    													try
    													{
    														//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Tentativa de mover arquivo para backup: " + arquivoTxt + ".");
    														//Replicator.RenameArquivoAposDownload(targetPathStr, nomeFolderAux, ftpDestino);
    
    														resultado = Replicator.RenameFileName(_filesInFolder[key].ToString(), nomeFolderAux + hora, ftpDestino,
    															@PASTA_ORIGEM_ARQ,
    															@PASTA_BACKUP_ARQ,
    															ref caminhoOrigem, ref caminhoDestino);
    
    														if (resultado == string.Empty)
    														{
    															//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Movido arquivo para backup: " + arquivoTxt + ".");
    															finaliza = true;
    														}
    														else
    														{
    															hora = "_" + DateTime.Now.ToString("HHmmss");
    															//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup - origem: " + caminhoOrigem + ".");
    															//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup - destino: " + caminhoDestino + ".");
    														}
    													}
    													catch (Exception ex)
    													{
    														//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup: " + arquivoTxt + ".");
    														//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup: " + ex.Message + ".");
    														//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup - origem: " + caminhoOrigem + ".");
    														//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup - destino: " + caminhoDestino + ".");
    													}
    												}
    												else
    													hora = "_" + DateTime.Now.ToString("HHmmss");
    
    												if (contadorexecucao1 > 10)
    												{
    													//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup: " + arquivoTxt + ".");
    													finaliza = true;
    												}
    											}
    										}
    										catch (Exception)
    										{
    											//Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro ao mover arquivo para backup: " + arquivoTxt + ".");
    										}
    									}
    								}
    								catch (Exception ex)
    								{
    									//if(download)
    									//    Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro mover arquivo backup: " + arquivoTxt + ".");
    									//else
    									Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro download arquivo: " + arquivoTxt + ".");
    									Logger.Log(TipoLog.Info, TipoLogSource.Service, "Erro download arquivo: " + ex.Message + ".");
    								}
    							}
    						}
    					}
    				}
    				contadorExecucao = 5;
    			}
    			catch (Exception ex)
    			{
    				//Logger.Log(TipoLog.Erro, TipoLogSource.Service, "Tentativa recebimento " + contadorExecucao.ToString() + " erro " + TIPO_REGRA + " - " +
    				//	INICIAL_ARQUIVO + " - Message: " + ex.Message);
    				try
    				{
    					Exception stackTraceError = ex.InnerException;
    					string mensagem = Auxiliar.MontaStringLog(stackTraceError, ex.Message, ex.StackTrace, "RECEB DE ARQUIVOS - Inicial: " +
    						INICIAL_ARQUIVO + arquivoPass);
    					//Auxiliar.AdicionaEntradaLog(mensagem, System.Diagnostics.EventLogEntryType.Error);
    				}
    				catch
    				{
    					//Logger.Log(TipoLog.Erro, TipoLogSource.Service, "Erro gravação log de erro recebimento arquivo : " + arquivoPass);
    				}
    			}
    		}
    		#endregion recebimento
    	}
    

    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Net;
    using System.IO;
    
    namespace Common.ftpHelper
    {
        [Serializable]
        public class FTPConnection
        {
            string _username;
            string _password;
            public string _url;
    
    
            public FTPConnection()
            {
    
            }
    
            public FTPConnection(string ftpurl, string userName, string password)
            {
                _username = userName;
                _password = password;
                _url = "ftp://" + ftpurl;
            }
    
     
            /// <summary>
            /// Connect to ftp on specfic Url and related method
            /// </summary>
            /// <param name="SpecificPathOnFtpUrl"></param>
            /// <param name="Method"></param>
            /// <returns></returns>
            public FtpWebRequest ConnectToFtp(string SpecificPathOnFtpUrl, string Method, bool ftpUtilizaProxy)
            {
                FtpWebRequest ftpRequest = (FtpWebRequest)FtpWebRequest.Create(new Uri(SpecificPathOnFtpUrl));
                ftpRequest.UseBinary = true;
                ftpRequest.Credentials = new NetworkCredential(_username, _password);
                ftpRequest.Method = Method;
    
                if (ftpUtilizaProxy)
                    ftpRequest.Proxy = null;
                ftpRequest.KeepAlive = false;
                ftpRequest.UsePassive = true;
                return ftpRequest;
            }
    
            /// <summary>
            /// Get all files in ftp folder
            /// </summary>
            /// <param name="FolderUrl"></param>
            /// <returns></returns>
            public Dictionary<string, string> GetFileList(string ftpDestino, string nomePasta, string nomeFile, bool allFiles, bool ftpUtilizaProxy)
            {
                StringBuilder filesstring = new StringBuilder();
                WebResponse webResponse = null;
                StreamReader sreader = null;
                Dictionary<string, string> nomeFiles = null;
    
                string foldeUrl = Path.Combine(ftpDestino, nomePasta);
                foldeUrl = foldeUrl.Replace("\\", "/");
    
                try
                {
                    //you can change url to connect to ftp according to your need
                    FtpWebRequest ftpRequest = ConnectToFtp(foldeUrl, WebRequestMethods.Ftp.ListDirectory, ftpUtilizaProxy);
    
                    ftpRequest.Timeout = 30000;
    
                    webResponse = ftpRequest.GetResponse();
                    sreader = new StreamReader(webResponse.GetResponseStream());
                    string strline = sreader.ReadLine();
                    while (strline != null)
                    {
                        string nomeAux = Path.GetFileName(strline);
                        if ((nomeFile.Trim() == string.Empty) || nomeFile != string.Empty && nomeAux.ToLower() == nomeFile.ToLower())
                        {
                            if (nomeFiles == null)
                                nomeFiles = new Dictionary<string, string>();
    
                            nomeFiles.Add(nomeAux, (Path.Combine(ftpDestino, nomePasta, nomeAux)).Replace("\\", "/"));
                            if (!allFiles)
                                break;
                        }
                        strline = sreader.ReadLine();
                    }
                }
                catch (Exception ex)
                {
                    //do any thing with exception
                    throw ex;
                }
                finally
                {
                    if (sreader != null)
                    {
                        sreader.Close();
                    }
                    if (webResponse != null)
                    {
                        webResponse.Close();
                    }
                }
                return nomeFiles;
            }
    
            public void UploadFileToFtp(string ftpDestino, string pastaDestino, string arquivo, bool ftpUtilizaProxy)
            {
                FileInfo fileInf = new FileInfo(arquivo);
    
                // ---------- faz upload do arquivo ---------- 
    
                string folderUrl = Path.Combine(ftpDestino, pastaDestino, Path.GetFileName(arquivo));
                folderUrl = folderUrl.Replace("\\", "/");
    
                FtpWebRequest ftpRequest = ConnectToFtp(folderUrl, WebRequestMethods.Ftp.UploadFile, ftpUtilizaProxy);
                ftpRequest.ContentLength = fileInf.Length;
                ftpRequest.Timeout = 400000;
    
                int buffLength = 2048;
                byte[] buff = new byte[buffLength];
                int contentLen;
    
                FileStream fs = null;
                Stream strm = null;
                try
                {
                    fs = fileInf.OpenRead();
                    strm = ftpRequest.GetRequestStream();
                    contentLen = fs.Read(buff, 0, buffLength);
    
                    while (contentLen != 0)
                    {
                        strm.Write(buff, 0, contentLen);
                        contentLen = fs.Read(buff, 0, buffLength);
                    }
    
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    if (fs != null)
                    {
                        fs.Flush();
                        fs.Close();
                    }
                    if (strm != null)
                    {
                        strm.Close();
                        strm.Dispose();
                    }
                }
            }
    
    
            /// <summary>
            /// Download file from ftp and save at local path
            /// </summary>
            /// <param name="fileUrl"></param>
            /// <param name="localPath"></param>
            public void DownloadFileFromFtp(string ftpDestino, string pastaOrigem, string nomeArquivo, string localPath, bool ftpUtilizaProxy)
            {
                StringBuilder filesstring = new StringBuilder();
                WebResponse webResponse = null;
                Stream dfileResponseStream = null;
                FileStream dfileWriteStream = null;
    
                string fileUrl = Path.Combine(ftpDestino, pastaOrigem, nomeArquivo);
                fileUrl = fileUrl.Replace("\\", "/");
    
                try
                {
                    FtpWebRequest ftpRequest = ConnectToFtp(fileUrl, WebRequestMethods.Ftp.DownloadFile, ftpUtilizaProxy);
                    ftpRequest.Timeout = 300000;
                    ftpRequest.UseBinary = true;
                    webResponse = ftpRequest.GetResponse();
    
                    FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
                    dfileResponseStream = response.GetResponseStream();
                    dfileWriteStream = new FileStream(localPath, FileMode.Create);
    
                    int Length = 8192;
                    Byte[] buffer = new Byte[Length];
                    int bytesRead = dfileResponseStream.Read(buffer, 0, Length);
                    while (bytesRead > 0)
                    {
                        dfileWriteStream.Write(buffer, 0, bytesRead);
                        bytesRead = dfileResponseStream.Read(buffer, 0, Length);
                    }
                    response.Close();
                    webResponse = null;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    if (dfileResponseStream != null)
                    {
                        try
                        {
                            dfileResponseStream.Flush();
                            dfileResponseStream.Close();
                            dfileResponseStream.Dispose();
                        }
                        catch
                        { }
                    }
                    if (dfileWriteStream != null)
                    {
                        try
                        {
                            dfileWriteStream.Flush();
                            dfileWriteStream.Close();
                            dfileResponseStream.Dispose();
                        }
                        catch
                        { }
                    }
                    if (webResponse != null)
                    {
                        webResponse.Close();
                    }
                }
            }
    
            /// <summary>
            /// Obtains a response stream as a string
            /// </summary>
            /// <param name="ftp">current FTP request</param>
            /// <returns>String containing response</returns>
            /// <remarks>FTP servers typically return strings with CR and
            /// not CRLF. Use respons.Replace(vbCR, vbCRLF) to convert
            /// to an MSDOS string</remarks>
            private static string GetStringResponse(FtpWebRequest ftp)
            {
                //Get the result, streaming to a string
                string result = "";
                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {
                    long size = response.ContentLength;
                    using (Stream datastream = response.GetResponseStream())
                    {
                        using (StreamReader sr = new StreamReader(datastream))
                        {
                            result = sr.ReadToEnd();
                            sr.Close();
                        }
    
                        datastream.Close();
                    }
    
                    response.Close();
                }
    
                return result;
            }
    
            /// <summary>
            /// Verifica se folder existe e cria se não existir
            /// </summary>
            /// <param name="fileUrl"></param>
            /// <param name="nomeFolder"></param>
            /// <param name="erroRetorno"></param>
            /// <returns></returns>
            public string CriaFolderFtp(string fileUrl, bool ftpUtilizaProxy, ref string erroRetorno)
            {
                FtpWebResponse responseCreate = null;
                string retorno = string.Empty;
                erroRetorno = string.Empty;
                try
                {
                    // ---------- cria diretorio se nao existir ---------- 
                    FtpWebRequest ftpRequest = ConnectToFtp(fileUrl, WebRequestMethods.Ftp.MakeDirectory, ftpUtilizaProxy);
                    responseCreate = (FtpWebResponse)ftpRequest.GetResponse();
                }
                catch (Exception)
                {
                    erroRetorno = "Ocorreu um erro imprevisto ao tentar criar a pasta.";
                }
                finally
                {
                    if (responseCreate != null)
                    {
                        responseCreate.Close();
                    }
                }
                return retorno;
            }
    
        }
    }
    

    terça-feira, 1 de agosto de 2017 18:52
  • Muitíssimo obrigado... vou implementar e testar... 

    Obrigado mesmo!!!


    Fabio Aragao

    terça-feira, 1 de agosto de 2017 19:04