Source for file removefolder.php

Documentation is available at removefolder.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Installation
  4.  * @subpackage  Controller
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. /**
  13.  * Controller class to set the FTP data for the Joomla Installer.
  14.  *
  15.  * @package     Joomla.Installation
  16.  * @subpackage  Controller
  17.  * @since       3.1
  18.  */
  19. class InstallationControllerRemovefolder extends JControllerBase
  20. {
  21.     /**
  22.      * Execute the controller.
  23.      *
  24.      * @return  void 
  25.      *
  26.      * @since   3.1
  27.      */
  28.     public function execute()
  29.     {
  30.         // Get the application
  31.         /* @var InstallationApplicationWeb $app */
  32.         $app = $this->getApplication();
  33.  
  34.         // Check for request forgeries.
  35.         JSession::checkToken() or $app->sendJsonResponse(new Exception(JText::_('JINVALID_TOKEN'), 403));
  36.  
  37.         $path = JPATH_INSTALLATION;
  38.  
  39.         // Check whether the folder still exists
  40.         if (!file_exists($path))
  41.         {
  42.             $app->sendJsonResponse(new Exception(JText::sprintf('INSTL_COMPLETE_ERROR_FOLDER_ALREADY_REMOVED'), 500));
  43.         }
  44.  
  45.         // Check whether we need to use FTP
  46.         $useFTP = false;
  47.         if ((file_exists($path) && !is_writable($path)))
  48.         {
  49.             $useFTP = true;
  50.         }
  51.  
  52.         // Check for safe mode
  53.         if (ini_get('safe_mode'))
  54.         {
  55.             $useFTP = true;
  56.         }
  57.  
  58.         // Enable/Disable override
  59.         if (!isset($options->ftpEnable) || ($options->ftpEnable != 1))
  60.         {
  61.             $useFTP = false;
  62.         }
  63.  
  64.         if ($useFTP == true)
  65.         {
  66.             // Connect the FTP client
  67.             $ftp = JClientFtp::getInstance($options->ftp_host, $options->ftp_port);
  68.             $ftp->login($options->ftp_user, $options->ftp_pass);
  69.  
  70.             // Translate path for the FTP account
  71.             $file = JPath::clean(str_replace(JPATH_CONFIGURATION, $options->ftp_root, $path), '/');
  72.             $return = $ftp->delete($file);
  73.  
  74.             // Delete the extra XML file while we're at it
  75.             if ($return)
  76.             {
  77.                 $file = JPath::clean($options->ftp_root . '/joomla.xml');
  78.                 if (file_exists($file))
  79.                 {
  80.                     $return = $ftp->delete($file);
  81.                 }
  82.             }
  83.  
  84.             // Rename the robots.txt.dist file to robots.txt
  85.             if ($return)
  86.             {
  87.                 $robotsFile = JPath::clean($options->ftp_root . '/robots.txt');
  88.                 $distFile = JPath::clean($options->ftp_root . '/robots.txt.dist');
  89.  
  90.                 if (!file_exists($robotsFile) && file_exists($distFile))
  91.                 {
  92.                     $return = $ftp->rename($distFile, $robotsFile);
  93.                 }
  94.             }
  95.  
  96.             $ftp->quit();
  97.         }
  98.         else
  99.         {
  100.             /*
  101.              * Try to delete the folder.
  102.              * We use output buffering so that any error message echoed JFolder::delete
  103.              * doesn't land in our JSON output.
  104.              */
  105.             ob_start();
  106.             $return = JFolder::delete($path) && (!file_exists(JPATH_ROOT . '/joomla.xml') || JFile::delete(JPATH_ROOT . '/joomla.xml'));
  107.  
  108.             // Rename the robots.txt.dist file if robots.txt doesn't exist
  109.             if ($return && !file_exists(JPATH_ROOT . '/robots.txt') && file_exists(JPATH_ROOT . '/robots.txt.dist'))
  110.             {
  111.                 $return = JFile::move(JPATH_ROOT . '/robots.txt.dist', JPATH_ROOT . '/robots.txt');
  112.             }
  113.  
  114.             ob_end_clean();
  115.         }
  116.  
  117.         // If an error was encountered return an error.
  118.         if (!$return)
  119.         {
  120.             $app->sendJsonResponse(new Exception(JText::_('INSTL_COMPLETE_ERROR_FOLDER_DELETE'), 500));
  121.         }
  122.  
  123.         // Create a response body.
  124.         $r = new stdClass;
  125.         $r->text = JText::_('INSTL_COMPLETE_FOLDER_REMOVED');
  126.  
  127.         /*
  128.          * Send the response
  129.          * This is a hack since by now, the rest of the folder is deleted and we can't make a new request
  130.          */
  131.         $this->sendJsonResponse($r);
  132.     }
  133.  
  134.     /**
  135.      * Method to send a JSON response. The data parameter
  136.      * can be a Exception object for when an error has occurred or
  137.      * a stdClass for a good response.
  138.      *
  139.      * @param   mixed  $response  stdClass on success, Exception on failure.
  140.      *
  141.      * @return  void 
  142.      *
  143.      * @since   3.1
  144.      */
  145.     public function sendJsonResponse($response)
  146.     {
  147.         // Check if we need to send an error code.
  148.         if ($response instanceof Exception)
  149.         {
  150.             // Send the appropriate error code response.
  151.             $this->setHeader('status', $response->getCode());
  152.             $this->setHeader('Content-Type', 'application/json; charset=utf-8');
  153.             $this->sendHeaders();
  154.         }
  155.  
  156.         // Send the JSON response.
  157.         JLoader::register('InstallationResponseJson', __FILE__);
  158.         echo json_encode(new InstallationResponseJson($response));
  159.  
  160.         // Close the application.
  161.         exit;
  162.     }
  163. }
  164.  
  165. /**
  166.  * JSON Response class for the Joomla Installer.
  167.  *
  168.  * @package     Joomla.Installation
  169.  * @subpackage  Response
  170.  * @since       3.1
  171.  */
  172. class InstallationResponseJson
  173. {
  174.     /**
  175.      * Constructor for the JSON response
  176.      *
  177.      * @param   mixed  $data  Exception if there is an error, otherwise, the session data
  178.      *
  179.      * @since   3.1
  180.      */
  181.     public function __construct($data)
  182.     {
  183.         // The old token is invalid so send a new one.
  184.         $this->token = JSession::getFormToken(true);
  185.  
  186.         // Get the language and send it's tag along
  187.         $this->lang = JFactory::getLanguage()->getTag();
  188.  
  189.         // Get the message queue
  190.         $messages = JFactory::getApplication()->getMessageQueue();
  191.  
  192.         // Build the sorted message list
  193.         if (is_array($messages) && count($messages))
  194.         {
  195.             foreach ($messages as $msg)
  196.             {
  197.                 if (isset($msg['type']) && isset($msg['message']))
  198.                 {
  199.                     $lists[$msg['type']][] = $msg['message'];
  200.                 }
  201.             }
  202.         }
  203.  
  204.         // If messages exist add them to the output
  205.         if (isset($lists) && is_array($lists))
  206.         {
  207.             $this->messages = $lists;
  208.         }
  209.  
  210.         // Check if we are dealing with an error.
  211.         if ($data instanceof Exception)
  212.         {
  213.             // Prepare the error response.
  214.             $this->error   = true;
  215.             $this->header  = JText::_('INSTL_HEADER_ERROR');
  216.             $this->message = $data->getMessage();
  217.         }
  218.         else
  219.         {
  220.             // Prepare the response data.
  221.             $this->error = false;
  222.             $this->data  = $data;
  223.         }
  224.     }
  225. }

Documentation generated on Tue, 19 Nov 2013 15:11:47 +0100 by phpDocumentor 1.4.3