Problema con el archivo ftp de Delphi
Subproceso de transferencia de unidad;
/////////////////////////// / ///////////////////////////////////////////////// ///// ///
//Descripción del módulo: clase de módulo central de transferencia FTP
//Función: especifique la fecha de descarga (carga) o el nombre del archivo, el sistema ejecutar la función de transferencia (admite transferencia continua).
//Observaciones: Este módulo pertenece a un módulo subproceso de la clase de transmisión.
//////////////////////////////////////////// // ////////////////////////////////////////
Conectar
Uso
Ventana, mensaje, sistema, variable, clase, gráficos, control, formulario,
Diálogos, ComCtrls, StdCtrls, IniFiles, IdIntercept, IdLogBase, IdLogEvent , IdAntiFreezeBase,
IdAntiFreeze, IdFTPList, IdBaseComponent, IdGlobal, IdComponent, IdTCPConnection, IdTCPClient, IdFTPCommon,
IdFTP
Tipo
TTransferThread = clase(al objeto)
Privado
{Declaración privada}
//Visualización de progreso
FProgressbar:TProgressbar;
>//Subir componentes principales
FFTP:tid FTP;
//Subir lista de clases internas
FCombobox:TCombobox;
/ /Visualización de información de carga
FLabel:TL Abel;
//Dirección FTP
FFTP _String_Host:String;
/ /Nombre de usuario FTP
FFTP_STR_USN: cadena;
//Contraseña de usuario FTP
FFTP_STR_PWD: cadena;
/ /Puerto FTP
FFTP _string_port:string;
//Etiqueta de carga FTP
FFTP_STR_UTAG:string;
>//Etiqueta de descarga FTP
FFTP_STR_DTAG: cadena;
//Carpeta especificada FTP
FFTP _STRO_FLOD: cadena de caracteres;
//Transferir tamaño de archivo
FFTP _ LWD _bytes: LongWord
//Hora de inicio de transferencia
FFTP _ DT_begin time:TDateTime;
//Velocidad de transmisión
FFTP_DUB_SPEED: Doble;
//Si se elimina el archivo fuente.
FFTP _ BOL _DEL: booleano;
//¿Se está transfiriendo el archivo?
FFTP _ BOL _ está transfiriendo: booleano;
//Función del cuadro de diálogo general dentro de la clase
Función MsgBox(Msg: string; iValue: integer) : Entero;
//Obtiene la carpeta temporal actual de Windows del usuario.
Función GetWinTempPath:String;
//Nombre del archivo de fecha generado a partir de la fecha
Función DateToFileName(DateTime:TDateTime):String;
//Genere el nombre de archivo completo según la etiqueta de carga/descarga.
Función getfile nombre completo(sTag:String;DateTime:TDateTime):String;
Protección
//Transferir funciones principales
Kernel de transferencia de función (iTag: Integer; sFile: string; bDelSFile: boolean = False): boolean
//Transfiere el evento WorkBegin del componente.
Procesar FFTPOnWorkBegin(sender: TObjectAWorkMode:TWorkMode; const AWorkCountMax:Integer);
//Transmitir el evento WorkEnd del componente.
Procesar FFTPOnWorkEnd(sender:TObjectAWorkMode:TWorkMode);
//Transmitir el evento de trabajo del componente.
Proceso FFTPOnWork(remitente: TObjectAWorkMode:TWorkMode; const AWorkCount: integer);
Público
//Constructor
Creación del constructor;
//Destructor
Destructor Destroy
//Propiedades de control de la barra de progreso
Propiedades de la barra de progreso :tbarra de progreso lectura fprogress barra escribir fprogress bar default nil
//Listar propiedades de control
Propiedad Combobox: TCombobox lee FCombobox escribe FCombobox default nil;
/ /Componente central FTP de solo lectura
Propiedad FTP:TidFTP leer FTP
//Control de etiquetas
Propiedad ol Abel:TLabel leer FLabel escribir FLabel predeterminado nil; Método de lista (este método debe especificar el cuadro combinado; de lo contrario, no será válido)
Lista de programas;
//Descargar archivos por fecha
Descarga del programa (dFecha :TDateTime); sobrecarga;
//Descargar archivos según el nombre del archivo
Descarga del programa (sFileName:String);
/ /Subir archivos por fecha
Subida del proceso (dDate:TDateTime); sobrecarga;
//Subir archivos según el nombre del archivo
Subida del proceso (sFileName:String);
//Ejecución del proceso; Sobrescribir;
Fin;
Rendimiento
Constructor TTransferThread. Crear;
Definir variables
FFini:archivo TiNi;
ruta del archivo:String;
Inicio
//Lectura completa de los parámetros relacionados con FTP.
FFTP_BOL_se está transfiriendo:= False;
Intente
ruta del archivo:= ExtractFilePath(application.exename)+' setup.ini';
FFini:=TIniFile. Crear (ruta del archivo);
fftp _ str _ host:= ffini . := ffini . readstring('Transferencia de archivos', 'Puerto del servidor', ' '); ReadString('Transferencia de archivos', 'Nombre de usuario', ' ');
Calle PWD FFTP. ReadString ('transferencia de archivos','contraseña','');
FFTP_ster_flood:=finney. ReadString ('transferencia de archivos', 'carpeta', ' ');
fftp _ str _ utag:= fini . p> p>
fftp _ str _ dtag:= ffini . ReadBool('Transferencia de archivos', 'Eliminar archivo fuente', FALSE);
Finney. Gratis;
Excepto...
MsgBox('¡No se puede leer la información de configuración de la conexión FTP! Verifique su archivo Setup.ini., MB _ OK+MB _ error de icono);
Salir;
Abortar
Fin
//Establecer parámetros relacionados con FTP
Intentar
p>FFTP:=TIdFTP. crear(ninguno);
FFTP. HOST:= FFTP_STR_HOST;
FFTP. PUERTO:= STR toint(FFTP _ STR _ PORT);
FFTP. Nombre de usuario:= FFTP_STR_USN;
FFTP. Contraseña:= FFTP_PWD;
FFTP. tipo de transferencia:= FTA scii;
//Event-driven
FFTP. en el trabajo:= FFTPOnWork;
FFTP. inicio del trabajo:= FFTPOnWorkBegin;
FFTP. OnWorkEnd:= FFTPOnWorkEnd;
FFTP. Connect(True, -1);
Excepto...
MsgBox('¡No se puede conectar al servidor FTP remoto!'#10#13'1. La dirección del servidor es incorrecto o El servidor no está disponible #10#13'2. El nombre de usuario o la contraseña son incorrectos.
Salir;
Abortar;
Fin. /p>
Fin;
Función TTransferThread.
DateToFileName(DateTime:TDateTime):String;
Definir variables
Año, mes, día: palabras;
sAño, sMes, sDía: String;
p>
Inicio
DecodeDate(fecha hora, año, mes, día //Fecha
sAño:= inttostr(Año);
sMonth:=inttostr(mes);
sDay:=inttostr(day);
//Año
Duración del caso (año)
4:sAño:= sAño;
3:sAño:= ' 0 '+sAño;
2:sAño:= ' 00 '+sAño;
1:sAño:= ' 000 '+sAño;
Otros
sAño:="";
Fin;
//Mes
Duración del caso (mes)
2:s mes:= s mes;
1:s mes:= ' 0 '+s mes ;
Otro
s mes:="";
Fin;
//día
Duración del caso (días)
2:sDay:= sDay;
1:sDay:= ' 0 '+sDay;
Otros
sDía:="";
Fin;
Si (sAño= ' ') o (sMes= ' ') o (sDía= ' ') entonces
Inicio
Resultado:="";
Salir;
Fin;
if(sAño<. >' ) y (sMes & lt& gt') y (sDay & lt& gt') luego
Inicio
Resultado:= sAño+s mes+sDía;
Fin;
Fin;
Destructor TTransferThread. Destruir;
Inicio
FProgressbar:= nil;
FCombobox:= nil;
FLabel:= nil;
FFTP. Salir;
FFTP. Gratis;
Fin;
Procedimiento TTransferThread. Descargar(dDate:TDateTime);
Iniciar
Si no es una transferencia BOL FFTP, entonces
Iniciar
TransferKernel(1, GetFileFullName( FFTP_STR_DTAG, dDate), FFTP_BOL_DEL
Fin
Fin
Procedimiento TTransferThread. Descargar(sFileName:String);
Iniciar
Si no es una transferencia BOL FFTP, entonces
TransferKernel(1,sFileName,FFTP_BOL_del);
Fin;
Proceso TTransferThread.
FFTPOnWork(remitente: TObjectAWorkMode:TWorkMode;
const AWorkCount: entero);
Definir variables
s, E: cadena
h, M, Seg, MS: Word;
tiempo total: TDateTime
tiempo dl: Doble
Inicio
Total; time:= Now-FFTP_DT_Start time; //Tiempo total de ejecución
Tiempo total de decodificación (tiempo total, horas, metros, segundos, milisegundos); //Eliminar tiempo\minutos\segundos\ milisegundos
<); p>Seg:= Sec+M * 6H * 3600; //Convertir a segundosdl time:= Sec+MS/1000; //Tiempo de descarga final
p>E:= Format('Tiempo de uso:% 2d:% 2d ', [secdiv 3600, (secdiv 60) mod 60, sec mod 60]);
Si DLTime & gt entonces 0
//Velocidad promedio por segundo: XX K/s
FFTP _ DUB _ SPEED:= {(velocidad promedio+}(un recuento de trabajo/1024)/dl tiempo {) /2};
Si FFTP_LWD_SPEED>ENTONCES 0
INICIO
seg:= Trunc((FFTP_LWD_NUMBER OF BYTES- recuento de trabajos)/1024)/fftp_dub_speed);
S := Format('Tiempo restante: % 2d: % 2d', [secdiv 3600, (secdiv 60) mod 60, sec mod 60]);
S:= ' VELOCIDAD:'+ formato float(' 0.00 KB/S ', FFTP _Dub_ SPEED)+S+E
Fin
Otro
s:="";
si(FLabel<>nil)y(asignación(FLabel))entonces
Iniciar
Freibel. AutoSize:= Verdadero;
Freibel. Título:=S;
Freibel. Actualizar
Fin;
si (FProgressBar & lt; & gtnil) y (asignación (FProgressBar)) luego
Iniciar
FBarra de progreso. posición:= un recuento de trabajo; //Visualización del progreso
FProgressBar. Actualización;
Fin;
Fin
Proceso TTransferThread. FFTPOnWorkBegin(remitente: TObject
AWorkMode:TWorkMode; const AWorkCountMax:Integer);
Inicio
FFTP _ BOL _ está transfiriendo: = True p>
FFTP _ DT _ hora de inicio:=now; //Hora de inicio
FFTP _ DUB _ SPEED:= 0.0; //Tasa de inicialización
if(FProgressBar & lt; & gtnil) y (assignment(FProgressBar)) entonces
Iniciar
Si AWorkCountMax & gt Entonces 0
Iniciar
FBarra de progreso.
max:= AWorkCountMax;
FFTP_LWD_bytes:=FProgressBar. Max
Fin
Otro
FProgressBar. max:= FFTP_LWD_bytes;
Fin;
Fin;
Procedimiento TTransferThread. FFTPOnWorkEnd(Remitente: TObject
AWorkMode:TWorkMode);
Inicio
FFTP _ BOL _ está transfiriendo:= False
fft_dub_speed; := 0.00;
si(FLabel <>nil) y (assign(FLabel)) entonces
comience
ftp Leibel. AutoSize:= Verdadero;
Freibel. Título:="";
Freibel. Actualizar
Fin;
si (FProgressBar & lt; & gtnil) y (asignación (FProgressBar)) luego
Iniciar
FBarra de progreso. Posición:= 0;
Fin
Fin
Función TTransferThread. getfile nombre completo(sTag:String;DateTime:TDateTime):String;
Inicio
Resultado:= sTag+DateToFileName(DateTime)+' FD. HXD ';
Fin;
Función TTransferThread. GetWinTempPath:String;
Definir variables
Directorio temporal: carácter de matriz [0..255]
Inicio
GetTempPath(255 , @TempDir);
Resultado:= strPas(TempDir);
Fin;
Procedimiento TTransferThread. Lista;
Definir variables
dir_List:TStringList;
carpeta encontrada:Boolean;
iCount:integer;
Iniciar
Si (FCombobox=nil) o (no asignado (FCombobox)), entonces
Iniciar
Salir;
Abortar;
Fin;
Dir_List:=TStringList. Create; //Crea una clase de lista de cadenas
Prueba
si no es FFTP. Conéctese a FFTP. Conexión;
FFTP. ChangeDir('/'); //Directorio raíz //Al directorio raíz del servidor
FFTP. List(Dir_List, '', True); //Obtener la lista de directorios
carpeta encontrada:= False;
FFTP. tipo de transferencia:= FTA scii; //Cambiar tipo de transferencia (tipo ASCII)
Para iCount:=0 a Dir_List. Cuenta-1:
Iniciar
si es FFTP. DirectoryListing.Items[iCount]. ItemType=ditDirectory luego
Iniciar
ifdir _ list . index of (fftp _ str _ floder)=-1 luego // determina que la carpeta no existe.
Iniciar
//Si no, continúa la búsqueda en bucle.
Continuar;
Fin
Otros
Inicio
//Si existe, salga del bucle directamente .
carpeta encontrada:= Verdadero;
Interrupción;
Fin;
Fin;
Fin;
Si FoundFolder, //juzga que la carpeta no existe.
Iniciar
FFTP. MakeDir(FFTP_STR_FROD); //No existe, cree una nueva carpeta.
Fin;
FFTP. cambiar directorio(FFTP_STR_FROD);
FFTP. List(lista de directorios, ' *. 'HXD', false);
if Dir_List. Cuenta y luego 0
Iniciar
FCombobox. elementos:= Dir_Lista
Fin
Final
Directorio_Lista. Gratis;
Fin;
Fin;
Función TTransferThread. MsgBox(Msg: string; iValue: integer): integer;
Inicio
Resultado:= messagebox (application.handle, pchar (msg), 'Información del sistema', iValue+MB _ appl modal);
Fin;
Función TTransferThread. transferir kernel(iTag:Integer;sFile:string;
bDelSFile:boolean):boolean;
Definir variables
ruta stmp:String;
dir_List:TStringList;
carpeta encontrada:Boolean;
iCount:integer;
Inicio
sTmpPath:= GetWinTempPath; //Obtener el directorio temporal del sistema local
Dir_List:=TStringList. Create; //Crea una clase de lista de cadenas
Prueba
si no es FFTP. Conéctese a FFTP. Conexión;
FFTP. ChangeDir('/'); //Directorio raíz//Al directorio raíz del servidor
FFTP. tipo de transferencia:= FTA scii; //Cambiar el tipo de transferencia (tipo ASCII)
FFTP. List(Dir_List, '', True); //Obtener lista de directorios
carpeta encontrada:= False;
Para iCount:=0 a Dir_List. Cuenta-1 haz
Iniciar
Iffftp. listado de directorios.elementos[icount]. tipo de elemento = ditdirectoryentonces//es un directorio.
Inicie
ifdir _ list . index of (fftp _ str _ floder)=-1 y luego // juzgue que la carpeta no existe.
Iniciar
//Si no, continúa la búsqueda en bucle.
Continuar;
Fin
Otros
Inicio
//Si existe, salga del bucle directamente .
carpeta encontrada:= Verdadero;
Interrupción;
Fin;
Fin;
Fin;
Si FoundFolder, entonces // determina que la carpeta no existe.
Iniciar
FFTP. MakeDir(FFTP_STR_FLOUD); //No existe, cree una nueva carpeta.
Fin;
//Cambiar tipo de transferencia
FFTP. tipo de transferencia:= ft binario;
Intente
// Si se encuentra el directorio correspondiente, cambie la ruta.
FFTP. change dir(FFTP_STR_FLOUD);
//0 se está subiendo.
Si iTag=0, entonces
Inicie
pruebe
FFTP. Put(sTmpPath+sFile,sFile);
Excepto...
MsgBox('¡Error al cargar el archivo! El motivo es el siguiente:' #13#10'1. El ¡el servidor no está abierto y tiene permiso para escribir archivos! #10#13'2.'¡Excepción del programa, vuelva a cargar', error de icono MB _ OK+
Abortar
Fin;
bytes FFTP LWD:=FFTP. Size(sFile);
Si bDelSFile, entonces // elimina el archivo fuente local
Inicio
eliminar archivo(sTmpPath+sFile);
Fin;
Resultado:=Verdadero;
FFTP. Desconectar;
Fin;
//1 para descargar.
Si iTag=1, entonces
Iniciar
//El archivo ya existe
Probar
FFTP Bytes LWD:=FFTP. Tamaño (sFile);
Si el archivo existe (sTmpPath+sFile), entonces
Iniciar
Case MsgBox('El archivo ya existe, ¿quieres ¿continuar?'# 13#10 'Sí-Continuar' #10#13 'No sobrescribir' #13#10 'Cancelar-Cancelar operación', MB_yesnocancel
Comenzar
FFTP _ LWD _ Bytes:= FFTP_LWD_bytes-tamaño del archivo por nombre (sTmpPath+sFile);
//Descripción del parámetro: archivo de origen, archivo de destino, si se sobrescribe, si se activa una excepción (Verdadero significa no activar
FFTP.Get(sFile,sTmpPath+sFile,False,True);
End;
IDNO:Start
FFTP.Get(sFile,sTmpPath+sFile,True);
Fin;
IDCANCEL:
Inicio
FFTP_BOL_ está transfiriendo:= False;
Fin;
Fin;
Fin
Else //El archivo no existe
p>Inicio
FFTP.Get(sFile,sTmpPath+sFile,True);
Fin;
Excepto...
MsgBox('¡Error al cargar el archivo! El motivo es el siguiente:' #13#10'1.
¡El servidor no tiene permiso para abrir y escribir el archivo! #10#13'2.'Excepción del programa, ¡súbelo de nuevo! ',MB_OK+MB_icon error);
Abortar;
Fin;
Si bDelSFile, //eliminar el archivo fuente remoto
Inicie
FFTP. Eliminar(sArchivo);
Fin;
FFTP. Desconectar;
Fin;
Excepto...
FFTP. Salir;
Resultado:=false;
Fin;
Final
Lista_directorios. Gratis
Fin;
Fin
Proceso TTransferThread. Upload(dDate:TDateTime);
Iniciar
Si no es una transferencia BOL FFTP, entonces
TransferKernel(0, GetFileFullName(FFTP_STR_DTAG, dDate), FFTP_BOL _del);
Fin;
Procedimiento TTransferThread. Upload(sFileName:String);
Iniciar
Si no es una transferencia BOL FFTP, entonces
TransferKernel(0,sFileName,FFTP_BOL_del);
Fin;
Fin.