/**
* Función para consultar actualizaciones desde el servidor.
* Devuelve un arreglo con las actualizaciones. En caso de error se
* retorna FALSE.
*
* @return array|FALSE
*/
public function find_updates()
{
// Obtenemos el manejador de paquetes.
$pkg_manager = Plugin_Manager::get_instance();
// Generamos el listado de paquetes.
$pkg_list = array();
foreach (array_keys($pkg_manager->load()) as $nombre) {
// TODO: ver si es lógico omitir los desactivados.
// Cargamos el paquete.
$pkg_info = $pkg_manager->get($nombre)->info();
$pkg_list[Update_Utils::make_hash($pkg_info->nombre)] = $pkg_info->version;
}
unset($pkg_manager);
// Cargamos la clase de peticiones.
$c_o = new Update_Client($this->server, $this->token);
// Pedimos la lista de actualizaciones.
try {
$upd_list = $c_o->check_updates($pkg_list);
} catch (Update_Exception_Client_Token $e) {
return FALSE;
} catch (Update_Exception_Client_Forbiden $e) {
return FALSE;
} catch (Update_Exception_Client_Missed $e) {
return FALSE;
}
return $upd_list;
}
/**
* Instalamos un nuevo tema.
*/
public function action_instalar_tema()
{
// Cargamos la vista.
$vista = View::factory('admin/configuracion/instalar_tema');
// Valores por defecto.
$vista->assign('error_carga', FALSE);
if (Request::method() == 'POST') {
$error = FALSE;
// Verifico el envio correcto de datos.
if (isset($_FILES['theme'])) {
// Cargo los datos del archivo.
$file = $_FILES['theme'];
// Verifico el estado.
if ($file['error'] !== UPLOAD_ERR_OK) {
$error = TRUE;
switch ($file['error']) {
case UPLOAD_ERR_INI_SIZE:
case UPLOAD_ERR_FORM_SIZE:
$vista->assign('error_carga', 'El tamaño del archivo es incorrecto.');
break;
case UPLOAD_ERR_PARTIAL:
$vista->assign('error_carga', 'Los datos enviados están corruptos.');
break;
case UPLOAD_ERR_NO_FILE:
$vista->assign('error_carga', 'No has seleccionado un archivo.');
break;
case UPLOAD_ERR_NO_TMP_DIR:
case UPLOAD_ERR_CANT_WRITE:
$vista->assign('error_carga', 'Error interno al cargar el archivo. Reintente. Si el error persiste contacte al administrador.');
break;
case UPLOAD_ERR_EXTENSION:
$vista->assign('error_carga', 'La configuración del servidor no permite archivo con esa extensión.');
break;
}
} else {
// Cargo el mime.
$file['type'] = Update_Utils::get_mime($file['tmp_name']);
// Verifico esté dentro de los permitidos.
if (!in_array(Update_Utils::mime2compresor($file['type']), Update_Compresion::get_list())) {
$error = TRUE;
$vista->assign('error_carga', 'El tipo de archivo no es soportado. Verifique la configuración del servidor.');
}
}
} else {
$error = TRUE;
$vista->assign('error_carga', 'No has seleccionado un archivo.');
}
// Verifico el contenido de los datos.
if (!$error) {
// Armo directorio temporal para la descargar.
$tmp_dir = TMP_PATH . uniqid('pkg_') . DS;
mkdir($tmp_dir, 0777, TRUE);
// Realizo la descompresión.
$compresor = Update_Compresion::get_instance(Update_Utils::mime2compresor($file['type']));
$compresor->set_temp_path($tmp_dir);
if (!$compresor->decompress($file['tmp_name'])) {
// Limpio salidas.
Update_Utils::unlink($file['tmp_name']);
Update_Utils::unlink($tmp_dir);
// Informo del error.
$error = TRUE;
$vista->assign('error_carga', 'No se pudo descomprimir el archivo. Compruebe que sea correcto.');
} else {
// Verifico que sea correcto.
if (is_dir($tmp_dir) && file_exists($tmp_dir . DS . 'theme.php') && file_exists($tmp_dir . DS . 'views') && $tmp_dir . DS . 'assets') {
// Cargo configuraciones.
$data = configuracion_obtener($tmp_dir . DS . 'theme.php');
// Verifico su contenido.
if (is_array($data)) {
if (isset($data['nombre']) && isset($data['author'])) {
$theme_name = preg_replace('/(\\s|[^a-z0-9])/', '', strtolower($data['nombre']));
}
}
if (!isset($theme_name)) {
// Limpio salidas.
Update_Utils::unlink($file['tmp_name']);
Update_Utils::unlink($tmp_dir);
// Informo del error.
$error = TRUE;
$vista->assign('error_carga', 'El archivo de descripción del tema es inválido.');
}
} else {
// Limpio salidas.
Update_Utils::unlink($file['tmp_name']);
Update_Utils::unlink($tmp_dir);
// Informo del error.
$error = TRUE;
$vista->assign('error_carga', 'No se trata de un tema válido.');
}
}
}
// Genero directorios.
if (!$error) {
// Generamos el path donde se va a alojar.
$target_path = APP_BASE . DS . VIEW_PATH . $theme_name . DS;
// Verifico directorio donde alojar.
if (!file_exists($target_path)) {
// Creo el directorio del tema.
if (!@mkdir($target_path, 0777, TRUE)) {
// Limpio salidas.
Update_Utils::unlink($target_path);
Update_Utils::unlink($file['tmp_name']);
Update_Utils::unlink($tmp_dir);
// Informo del error.
$vista->assign('error_carga', '1No se pudo alojar el tema en su lugar correspondiente. Verifica los permisos del directorio de temas.');
$error = TRUE;
}
}
}
// Realizo actualizacion.
if (!$error) {
// Realizo el movimiento.
if (!Update_Utils::copyr($tmp_dir, $target_path)) {
// Limpio salidas.
Update_Utils::unlink($file['tmp_name']);
Update_Utils::unlink($tmp_dir);
Update_Utils::unlink($target_path);
// Informo del error.
$vista->assign('error_carga', 'No se pudo alojar el tema en su lugar correspondiente. Verifica los permisos del directorio de temas.');
} else {
// Limpio directorios.
Update_Utils::unlink($file['tmp_name']);
Update_Utils::unlink($tmp_dir);
// Informo resultado.
$_SESSION['flash_success'] = 'El tema se instaló correctamente.';
// Redireccionamos.
Request::redirect('/admin/configuracion/temas');
}
}
}
// Seteamos el menu.
$this->template->assign('master_bar', parent::base_menu('admin'));
// Cargamos plantilla administracion.
$admin_template = View::factory('admin/template');
$admin_template->assign('contenido', $vista->parse());
unset($portada);
$admin_template->assign('top_bar', Controller_Admin_Home::submenu('configuracion_temas'));
// Asignamos la vista a la plantilla base.
$this->template->assign('contenido', $admin_template->parse());
}
/**
* Realizamos el proceso de instalación o actualización.
* @param bool $update Si es una actualización.
* @return bool
*/
public function install($update = TRUE)
{
// Obtenemos el directorio temporal para el paquete.
$temp_dir = $this->get_tmp_dir();
// Descomprimimos el paquete.
if (!$this->descomprimir($temp_dir)) {
// Limpiamos el directorio temporal.
Update_Utils::unlink($temp_dir);
// No se pudo descomprimir.
throw new Exception('Imposible descomprimir el paquete.');
}
// Obtenemos la información del paquete.
if (!file_exists($temp_dir . 'info.json')) {
// Limpiamos el directorio temporal.
Update_Utils::unlink($temp_dir);
// No se pudo descomprimir.
throw new Exception('El paquete es inválido.');
}
$data = json_decode(file_get_contents($temp_dir . 'info.json'));
// Obtenemos el nombre del paquete.
$pkg_name = $data->nombre;
// Cargamos el archivo para personalizar la actualización.
if (file_exists($temp_dir . '/install.php')) {
@(include $temp_dir . '/install.php');
if (class_exists('Install')) {
// Cargamos el instalador.
$install = new Install($temp_dir, $update);
}
}
// Ejecutamos pre_instalacion.
if (isset($install)) {
// Verificamos soporte.
if (method_exists($install, 'before')) {
$install->before();
}
}
// Movemos los archivos.
Update_Utils::copyr($temp_dir . DS . 'files' . DS, Plugin_Manager::nombre_as_path($pkg_name));
// Ejecutamos post_instalacion.
if (isset($install)) {
// Verificamos soporte.
if (method_exists($install, 'after')) {
$install->after();
}
}
// Limpiamos archivos de la instalación y salimos.
return Update_Utils::unlink($temp_dir);
}
/**
* Prueba descarga de un plugin.
*/
public function action_install()
{
Dispatcher::call('');
// Prueba del uso de memoria.
// Nombre del plugin.
$p_nombre = "Test Plugin";
// Borramos el plugin.
// if (file_exists(Plugin_Manager::nombre_as_path($p_nombre)))
// {
// Update_Utils::unlink(Plugin_Manager::nombre_as_path($p_nombre));
// }
// Objeto manejador de plugins.
$pkg_manager = Plugin_Manager::get_instance();
// Verificamos su existencia
$o_plugin = $pkg_manager->get(Plugin_Manager::make_name($p_nombre));
if ($o_plugin === NULL) {
// Realizamos la instalación.
// Cargamos el actualizador.
$o_updater = new Update_Updater();
// Descargamos el paquete e instalamos el paquete. Se usa 1 para mostrar actualizaciones.
if ($o_updater->install_package(Update_Utils::make_hash($p_nombre), 1)) {
// Actualizamos la cache.
$pkg_manager->regenerar_lista();
// Cargamos el paquete.
$o_plugin = new Plugin_Plugin($p_nombre);
// Realizamos la actualizacion.
$o_plugin->install();
// Activamos el paquete.
$pkg_manager->set_state(Plugin_Manager::make_name($p_nombre), TRUE, TRUE);
echo "Instalación existosa";
} else {
echo "Problema al realizar la instalación";
}
} else {
// Buscamos actualizaciones.
$upd_id = $o_plugin->check_updates();
if ($upd_id === FALSE) {
echo "No hay actualizaciones";
} else {
// Instalamos la actualizacion.
// Desactivo el plugin.
if ($o_plugin->info()->estado) {
$o_plugin->remove();
}
// Directorio del plugin.
$orig_path = Plugin_Manager::nombre_as_path($p_nombre);
$tmp_path = rtrim($orig_path, '/') . '.bkp';
// Realizamos una copia.
Update_Utils::copyr($orig_path, $tmp_path);
// Borramos el original.
Update_Utils::unlink($orig_path);
// Cargamos el actualizador.
$o_updater = new Update_Updater();
// Descargamos el paquete e instalamos el paquete.
if (!$o_updater->install_package(Update_Utils::make_hash($p_nombre), $upd_id)) {
// Recuperamos el original.
Update_Utils::copyr($tmp_path, $orig_path);
echo "No se pudo actualizar a la versión {$upd_id}.";
} else {
echo "Actualización a la versión {$upd_id} exitosa.";
}
// Realizamos la instalación.
$o_plugin->install();
// Borramos la copia.
Update_Utils::unlink($tmp_path);
}
}
if (!Request::is_cli()) {
echo "<br />";
}
}
// Iniciamos el usuario.
Usuario::start();
// Cargo el tema actual.
define('THEME', Theme::actual());
// Iniciamos el manejo de errores.
Error::get_instance()->start(DEBUG);
// Verificamos bloqueos.
$lock = new Mantenimiento();
if ($lock->is_locked()) {
if ($lock->is_locked_for(IP::get_ip_addr())) {
//TODO: utilizar vista para dar flexibilidad.
die("Modo mantenimiento activado.");
}
}
// Definimos el directorio temporal. Puede definir uno manualmente.
define('TMP_PATH', Update_Utils::sys_get_temp_dir() . DS);
// Comprobamos que exista la configuración de la base de datos.
if (!file_exists(CONFIG_PATH . DS . 'database.php')) {
//TODO: lo mandamos al instalador.
die("Falta configurar la base de datos");
}
// Cargamos la cache.
Cache::get_instance();
// Cargamos las configuraciones del gestor de actualizaciones.
if (file_exists(CONFIG_PATH . DS . 'update.php')) {
// Configuraciones::load(CONFIG_PATH.DS.'update.php', TRUE);
}
// Comprobamos que existe la lista de plugins.
if (!file_exists(APP_BASE . DS . PLUGINS_PATH . DS . 'plugin.php')) {
// Generamos la lista de plugins.
Plugin_Manager::get_instance()->regenerar_lista();
/**
* Verificamos nuevas versiones del plugin.
* Esta función no se recomienda por su costo, ya que para obtener las
* actualizaciones de un plugin ha de enviarse la lista para que el servidor
* resuelva dependencias (inclusivas o exclusivas).
* @return FALSE|int Numero de versión o false si no hay actualizaciones.
*/
public function check_updates()
{
// Cargamos objeto de actualizaciones.
$o_update = new Update_Updater();
// Obtenemos la lista de actualizaciones.
$upd_list = $o_update->find_updates();
if (is_object($upd_list)) {
if ($upd_list instanceof stdClass) {
$upd_list = (array) $upd_list;
}
}
// Verificamos el resultado.
if (is_array($upd_list)) {
$k = (string) Update_Utils::make_hash($this->data->nombre);
if (isset($upd_list[$k])) {
return $upd_list[$k];
} else {
return FALSE;
}
} elseif (is_object($upd_list)) {
$k = (string) Update_Utils::make_hash($this->data->nombre);
if (isset($upd_list->{$k})) {
return $upd_list->{$k};
} else {
return FALSE;
}
} else {
//TODO: verificar que no sea un error.
return FALSE;
}
}
