PHP FTP Manager: Transfiere y Manipula Archivos vía FTP

Con los nuevos requerimientos que se ven día a día en la administración de un sitio web, una de las opciones de todo administrador web, es la gestión de archivos. Un claro ejemplo es WordPress, ya que también tiene un gestor de archivos el cual puedes editar, claro que con limitado acceso a ciertos archivos (de los temas por ejm).

Pues en este tutorial enseñare a manipular los archivos de un servidor remoto, como Listar los archivos, eliminarlos, crear archivos y directorios, asi como cambiar de directorio actual. Esto lo haremos mediante una clase escrita en PHP publicada en PHPClasses, a la cual pueden acceder con una cuenta y descargarla la cual se llama PHP FTP Manager esta hecho con Programación Orientada a Objetos.

1. DATOS DE CONEXION AL SERVIDOR FTP

Bien como debemos imaginarnos, se necesita de un USUARIO y una CONTRASEÑA para acceder a un servidor vía FTP, ademas de la dirección del servidor y el puerto de entrada. Ademas de controlar la visualización de errores al momento de conectarse al servidor FTP.

[parameters]
FTP_SERVER = "ftp.servidor.com" ;Direccion FTP del server(puede ser URL o Direccion IP
FTP_PORT = 21 ;Este es el puerto de acceso al servidor FTP, por defecto es 21
FTP_USER = "Anonymous"; Nombre del usuario de Acceso
FTP_PASSWORD = "contrasena" ; Contrasena de Acceso al servidor FTP, debes tener cuidado.
SHOW_ERRORS = 1 ;Si se especifica en 1 mostrara todos los errores posibles, si es 0 no mostrara nada

Este archivo lo guardamos con el nombre parameters.ini, y lo guardamos en al raiz de nuestro ejemplo.

2.- ESCRIBIENDO EL CÓDIGO PHP DE NUESTRO ARCHIVO DE CONEXIÓN:

Ahora nos toca escribir la base de nuestro ejemplo. Primero realizamos la conexión al servidor FTP, leyendo primero nuestro archivo de configuración, el cual ya hemos creado. he aquí el código del archivo de conexión al servidor FTP. El archivo lo llamaran ftp-connect.php

<?php
	abstract class connection
	{
		private static $_server;
		private static $_user;
		private static $_password;
		private static $_port;
		private static $ini_file = "parameters.ini"; // Archivo de configuracion
		private static $_showErrors;
		public $connection;

		protected function print_error($exception)
		{
			die($exception);
		}
		protected function isUsable($tocheck)
		{
			if (empty($tocheck) || ($tocheck == ''))
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		private function parse_config_data()
		{
			$config_data = parse_ini_file(self::$ini_file); // recibiendo la configuracion del archivo 'parameters.ini'
			if (!self::isUsable( $config_data["FTP_SERVER"]) || !self::isUsable($config_data["FTP_USER"]) || !self::isUsable($config_data["FTP_PASSWORD"]))
			{
				return self::print_error("EmptyDataException");
			}
			//asginando los datos de configuracio a las variables
			self::$_server = $config_data["FTP_SERVER"];
			self::$_port = $config_data["FTP_PORT"];
			self::$_user = $config_data["FTP_USER"];
			self::$_password = $config_data["FTP_PASSWORD"];
			self::$_showErrors = $config_data["SHOW_ERRORS"];
			return;
		}
		// esta funcion realiza la conexion al servidor ftp
		protected function _login()
		{
			if (!ftp_login($this->connection, self::$_user, self::$_password))
			{
				self::print_error("LoginErrorException");
			}
			else
			{
				return ftp_login($this->connection, self::$_user, self::$_password);
			}
		}
		public function __construct()
		{
			self::parse_config_data(); // Asigna los datos del archivo parameters.ini
			error_reporting(self::$_showErrors); // reporta errores si los hay
			if (!self::isUsable(self::$_port))
			{
				if (ftp_connect(self::$_server)) // Verifica si hay conexion con el servidor
				{
					$this->connection = ftp_connect(self::$_server); // Asigna la conexion
				}
				else
				{
					self::print_error("InvalidDataException"); // si aparce un error lo muesra
				}
			}
			else
			{
				if (ftp_connect(self::$_server, self::$_port))
				{
					$this->connection = ftp_connect(self::$_server, self::$_port); // establesco la conexion mediante la url o IP del servidor mas su puerto
				}
				else
				{
					self::print_error("InvalidDataException");
				}
			}
			return self::_login(); // en caso de funcionar todo bien realiza la conexion
		}
	}
?>

3.- LISTANDO LOS ARCHIVOS Y DIRECTORIOS DEL SERVIDOR FTP:

Ahora una vez que tenemos el código de conexión, pues vamos a estructurar la lista de los archivos y directorios en el servidor, y así ejecutaremos solo las opciones que se especifiquen en un array dentro del archivo del listado, tener en cuenta que la manipulación de los archivos y directorios de un servidor debe ser llevado a cabo por una persona con conocimientos básicos si no se afectara a las paginas que se puedan encontrar ahi. Bien una vez dicho esto, el array con las opciones aceptadas son array("name", "goto", "display", "create", "delete");, Obviamente ya saben para que funciona cada una de ellas. Ahora a mostrar el código del archivo ftp-directory.php

<?php
	require_once("ftp-connect.php");

	class ftp_directory extends connection
	{
		//Establece las opciones/permisos de navegacion
		private static $_acceptedOptions = array("name", "goto", "display", "create", "delete");
		public function manipulate_directory($params, $others)
		{
			if (!self::isUsable($params) || !in_array($params, self::$_acceptedOptions))
			{
				return self::print_error("InvalidParameterException");
			}
			if ($params == "name") // nombre del usuario
			{
				return self::pwd();
			}
			else if ($params == "goto") // Ir a un directorio especifico
			{
				if (!self::isUsable($others))
				{
					return self::print_error("InvalidInstructionRequestException");
				}
				else
				{
					if (self::chdir($others)) // CAMBIAR DE DIRECTORIO
					{
						return "Directory Change Successful";
					}
					else
					{
						return "We were unable to change the directory";
					}
				}
			}
			else if ($params == "display") // VER Y/O LISTAR LOS ARCHIVOS Y DIRECTORIOS
			{
				if (!self::isUsable($others))
				{
					return self::print_error("InvalidInstructionRequestException");
				}
				else
				{
					return self::nlist($others);
				}
			}
			else if ($params == "create") // CREAR UN DIRECTORIO
			{
				if (!self::isUsable($others))
				{
					return self::print_error("InvalidInstructionRequestException");
				}
				else
				{
					if (self::mkdir($others))
					{
						return "$others created successfully";
					}
					else
					{
						return "We Could Not Create The Directory: $others";
					}
				}
			}
			else if ($params == "delete") // BORRAR UN DIRECTORIO
			{
				if (!self::isUsable($others))
				{
					return self::print_error("InvalidInstructionRequestException");
				}
				else
				{
					if (self::rmdir($others))
					{
						return "$others deleted successfully";
					}
					else
					{
						return "We Could Not Delete The Directory: $others";
					}
				}
			}
		}

		// Funcion que verifica en cada funcion que la conexion y la clave que se proporciono
		// sea la correcta
		private function pwd()
		{
			return ftp_pwd($this->connection);
		}

		// Funcion que nos permite navegar entre directorios
		private function chdir($location)
		{
			if ($location == "true")
			{
				if (!ftp_cdup($this->connection))
				{
					return false;
				}
				else
				{
					return true;
				}
			}
			else
			{
				if (!ftp_chdir($this->connection, $location))
				{
					return false;
				}
				else
				{
					return true;
				}
			}
		}
		// funcion que recibe la lista de directorio y la muestra
		protected function nlist($location)
		{
			if (!ftp_nlist($this->connection, $location))
			{
				return "Unable to retrieve current directories files/folders";
			}
			else
			{
				return ftp_nlist($this->connection, $location);
			}
		}
		protected function mkdir($name)
		{
			if (!ftp_mkdir($this->connection, $name))
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		// Funcion que BORRA un directorio
		protected function rmdir($name)
		{
			if (!ftp_rmdir($this->connection, $name))
			{
				return false;
			}
			else
			{
				return true;
			}
		}
	}
?>

4.- OPCIÓN PARA DESCARGA DE ARCHIVOS

Ahora el ultimo elemento de nuestra app web, es una función para realizar la descarga de archivos del servidor FTP, es mas simple que los anteriores archivos, lo llamaremos ftp.php

<?php
	require_once("ftp-directory.php");
	class ftp extends ftp_directory
	{
		/* // FUNCION PARA DESCARGAR LOS ARCHIVOS
				A ESTA FUNCION LE ENVIAMOS:
				$file: Archivo a Descargar
				$location : Ruta donde Donde se guardara
				$mode: Modo de Descarga
		*********************************************************/
		public function download($file, $location, $mode)
		{
			if ($mode != "FTP_ASCII" || $mode != "FTP_BINARY")
			{
				$mode == "FTP_ASCII";
			}
			if (!self::isUsable($location))
			{
				$location = $file;
			}
			if (!self::isUsable($file))
			{
				return self::print_error("InvalidParameterException");
			}
			if (ftp_get($this->connection, $location, $file, $mode))
			{
				return "Download Successful. $file saved to $location";
			}
			else
			{
				return "Could Not Download Specified File";
			}
		}
	}
?>

5.- CREANDO LA INTERFAZ

Ahora Crearemos la interfaz para desplegar nuestra app web. Que no es cosa del otro mundo, Solo Descargamos un archivo para ver si funciona la descarga, luego se muestra el directorio actual de trabajo, y se lista los archivos y directorios del directorio actual. Finalmente se traslada a la carpeta publica(donde van los archivos de las webs).

<?php
	require_once("ftp.php");
	$myFtp = new ftp();
	// DESCARGANDO UN ARCHIVO DE PRUEBA DE EL SERVIDOR FTP
	$file = $myFtp->download("README.txt", "", FTP_ASCII);
	echo $file;
	//IMPRIME EL NOMBRE DEL DIRECTORIO ACTUAL DE TRABAJO
	$nameOfCurrentDirectory = $myFtp->manipulate_directory("name", "");
	echo $nameOfCurrentDirectory;
	//MUESTRA EL CONTENIDO DE ARCHIVOS Y DIRECTORIOS DEL DIRECTORIO ACTUAL
	$content = $myFtp->manipulate_directory("display", ".");
	foreach ($content as $member)
	{
		echo "<p>". $member."</p><br/><hr /><br />";
	}
	//CAMBIA EL DIRECTORIO ACTUAL AL DIRECTORIO PUBLICO
	$change = $myFtp->manipulate_directory("goto", "/public");
	echo $change;
?>

CONCLUSIÓN

Como se pueden dar cuenta no es muy difícil, a esto solo le falta un poco de diseño para poder mostrar de mejor manera el listado así como colocar enlaces a otras carpetas desde un link, como los FTP profesionales, claro que también mucha mas seguridad, pero esto es básicamente un buen ejemplo de como manipular los archivos y directorios de un servidor FTP con PHP FTP Manager. Les dejo el Link de Descarga.

Valora este Artículo
PHP FTP Manager: Transfiere y Manipula Archivos vía FTP
Qué te pareció?
Sobre el Autor

Soy un joven entusiasta, me gusta aprender por mi cuenta, soy de profesión Técnico en Computación e Informática, me gusta ayudar a la gente con sus problemas informáticos, aprecio la familia… Quiero y lograré alcanzar todos mis objetivos.

Comparte si te ha Gustado
Artículos Relacionados
Tags: