[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  /**
   4   * @package     Joomla.Administrator
   5   * @subpackage  com_installer
   6   *
   7   * @copyright   (C) 2008 Open Source Matters, Inc. <https://www.joomla.org>
   8   * @license     GNU General Public License version 2 or later; see LICENSE.txt
   9   */
  10  
  11  namespace Joomla\Component\Installer\Administrator\Model;
  12  
  13  use Joomla\CMS\Factory;
  14  use Joomla\CMS\Installer\Installer;
  15  use Joomla\CMS\Language\Text;
  16  use Joomla\CMS\MVC\Factory\MVCFactoryInterface;
  17  use Joomla\Database\DatabaseQuery;
  18  use Joomla\Database\Exception\ExecutionFailureException;
  19  use Joomla\Database\ParameterType;
  20  use Joomla\Utilities\ArrayHelper;
  21  
  22  // phpcs:disable PSR1.Files.SideEffects
  23  \defined('_JEXEC') or die;
  24  // phpcs:enable PSR1.Files.SideEffects
  25  
  26  /**
  27   * Installer Discover Model
  28   *
  29   * @since  1.6
  30   */
  31  class DiscoverModel extends InstallerModel
  32  {
  33      /**
  34       * Constructor.
  35       *
  36       * @param   array                $config   An optional associative array of configuration settings.
  37       * @param   MVCFactoryInterface  $factory  The factory.
  38       *
  39       * @see     \Joomla\CMS\MVC\Model\ListModel
  40       * @since   1.6
  41       */
  42      public function __construct($config = array(), MVCFactoryInterface $factory = null)
  43      {
  44          if (empty($config['filter_fields'])) {
  45              $config['filter_fields'] = array(
  46                  'name',
  47                  'client_id',
  48                  'client', 'client_translated',
  49                  'type', 'type_translated',
  50                  'folder', 'folder_translated',
  51                  'extension_id',
  52              );
  53          }
  54  
  55          parent::__construct($config, $factory);
  56      }
  57  
  58      /**
  59       * Method to auto-populate the model state.
  60       *
  61       * Note. Calling getState in this method will result in recursion.
  62       *
  63       * @param   string  $ordering   An optional ordering field.
  64       * @param   string  $direction  An optional direction (asc|desc).
  65       *
  66       * @return  void
  67       *
  68       * @since   3.1
  69       */
  70      protected function populateState($ordering = 'name', $direction = 'asc')
  71      {
  72          $app = Factory::getApplication();
  73  
  74          // Load the filter state.
  75          $this->setState('filter.search', $this->getUserStateFromRequest($this->context . '.filter.search', 'filter_search', '', 'string'));
  76          $this->setState('filter.client_id', $this->getUserStateFromRequest($this->context . '.filter.client_id', 'filter_client_id', null, 'int'));
  77          $this->setState('filter.type', $this->getUserStateFromRequest($this->context . '.filter.type', 'filter_type', '', 'string'));
  78          $this->setState('filter.folder', $this->getUserStateFromRequest($this->context . '.filter.folder', 'filter_folder', '', 'string'));
  79  
  80          $this->setState('message', $app->getUserState('com_installer.message'));
  81          $this->setState('extension_message', $app->getUserState('com_installer.extension_message'));
  82  
  83          $app->setUserState('com_installer.message', '');
  84          $app->setUserState('com_installer.extension_message', '');
  85  
  86          parent::populateState($ordering, $direction);
  87      }
  88  
  89      /**
  90       * Method to get the database query.
  91       *
  92       * @return  DatabaseQuery  The database query
  93       *
  94       * @since   3.1
  95       */
  96      protected function getListQuery()
  97      {
  98          $db = $this->getDatabase();
  99          $query = $db->getQuery(true)
 100              ->select('*')
 101              ->from($db->quoteName('#__extensions'))
 102              ->where($db->quoteName('state') . ' = -1');
 103  
 104          // Process select filters.
 105          $type     = $this->getState('filter.type');
 106          $clientId = $this->getState('filter.client_id');
 107          $folder   = $this->getState('filter.folder');
 108  
 109          if ($type) {
 110              $query->where($db->quoteName('type') . ' = :type')
 111                  ->bind(':type', $type);
 112          }
 113  
 114          if ($clientId != '') {
 115              $clientId = (int) $clientId;
 116              $query->where($db->quoteName('client_id') . ' = :clientid')
 117                  ->bind(':clientid', $clientId, ParameterType::INTEGER);
 118          }
 119  
 120          if ($folder != '' && in_array($type, array('plugin', 'library', ''))) {
 121              $folder = $folder === '*' ? '' : $folder;
 122              $query->where($db->quoteName('folder') . ' = :folder')
 123                  ->bind(':folder', $folder);
 124          }
 125  
 126          // Process search filter.
 127          $search = $this->getState('filter.search');
 128  
 129          if (!empty($search)) {
 130              if (stripos($search, 'id:') === 0) {
 131                  $ids = (int) substr($search, 3);
 132                  $query->where($db->quoteName('extension_id') . ' = :eid')
 133                      ->bind(':eid', $ids, ParameterType::INTEGER);
 134              }
 135          }
 136  
 137          // Note: The search for name, ordering and pagination are processed by the parent InstallerModel class (in extension.php).
 138  
 139          return $query;
 140      }
 141  
 142      /**
 143       * Discover extensions.
 144       *
 145       * Finds uninstalled extensions
 146       *
 147       * @return  int  The count of discovered extensions
 148       *
 149       * @since   1.6
 150       */
 151      public function discover()
 152      {
 153          // Purge the list of discovered extensions and fetch them again.
 154          $this->purge();
 155          $results = Installer::getInstance()->discover();
 156  
 157          // Get all templates, including discovered ones
 158          $db = $this->getDatabase();
 159          $query = $db->getQuery(true)
 160              ->select($db->quoteName(['extension_id', 'element', 'folder', 'client_id', 'type']))
 161              ->from($db->quoteName('#__extensions'));
 162          $db->setQuery($query);
 163          $installedtmp = $db->loadObjectList();
 164  
 165          $extensions = array();
 166  
 167          foreach ($installedtmp as $install) {
 168              $key = implode(
 169                  ':',
 170                  [
 171                      $install->type,
 172                      str_replace('\\', '/', $install->element),
 173                      $install->folder,
 174                      $install->client_id
 175                  ]
 176              );
 177              $extensions[$key] = $install;
 178          }
 179  
 180          $count = 0;
 181  
 182          foreach ($results as $result) {
 183              // Check if we have a match on the element
 184              $key = implode(
 185                  ':',
 186                  [
 187                      $result->type,
 188                      str_replace('\\', '/', $result->element),
 189                      $result->folder,
 190                      $result->client_id
 191                  ]
 192              );
 193  
 194              if (!array_key_exists($key, $extensions)) {
 195                  // Put it into the table
 196                  $result->check();
 197                  $result->store();
 198                  $count++;
 199              }
 200          }
 201  
 202          return $count;
 203      }
 204  
 205      /**
 206       * Installs a discovered extension.
 207       *
 208       * @return  void
 209       *
 210       * @since   1.6
 211       */
 212      public function discover_install()
 213      {
 214          $app   = Factory::getApplication();
 215          $input = $app->input;
 216          $eid   = $input->get('cid', 0, 'array');
 217  
 218          if (is_array($eid) || $eid) {
 219              if (!is_array($eid)) {
 220                  $eid = array($eid);
 221              }
 222  
 223              $eid = ArrayHelper::toInteger($eid);
 224              $failed = false;
 225  
 226              foreach ($eid as $id) {
 227                  $installer = new Installer();
 228                  $installer->setDatabase($this->getDatabase());
 229  
 230                  $result = $installer->discover_install($id);
 231  
 232                  if (!$result) {
 233                      $failed = true;
 234                      $app->enqueueMessage(Text::_('COM_INSTALLER_MSG_DISCOVER_INSTALLFAILED') . ': ' . $id);
 235                  }
 236              }
 237  
 238              // @todo - We are only receiving the message for the last Installer instance
 239              $this->setState('action', 'remove');
 240              $this->setState('name', $installer->get('name'));
 241              $app->setUserState('com_installer.message', $installer->message);
 242              $app->setUserState('com_installer.extension_message', $installer->get('extension_message'));
 243  
 244              if (!$failed) {
 245                  $app->enqueueMessage(Text::_('COM_INSTALLER_MSG_DISCOVER_INSTALLSUCCESSFUL'));
 246              }
 247          } else {
 248              $app->enqueueMessage(Text::_('COM_INSTALLER_MSG_DISCOVER_NOEXTENSIONSELECTED'));
 249          }
 250      }
 251  
 252      /**
 253       * Cleans out the list of discovered extensions.
 254       *
 255       * @return  boolean  True on success
 256       *
 257       * @since   1.6
 258       */
 259      public function purge()
 260      {
 261          $db = $this->getDatabase();
 262          $query = $db->getQuery(true)
 263              ->delete($db->quoteName('#__extensions'))
 264              ->where($db->quoteName('state') . ' = -1');
 265          $db->setQuery($query);
 266  
 267          try {
 268              $db->execute();
 269          } catch (ExecutionFailureException $e) {
 270              $this->_message = Text::_('COM_INSTALLER_MSG_DISCOVER_FAILEDTOPURGEEXTENSIONS');
 271  
 272              return false;
 273          }
 274  
 275          $this->_message = Text::_('COM_INSTALLER_MSG_DISCOVER_PURGEDDISCOVEREDEXTENSIONS');
 276  
 277          return true;
 278      }
 279  
 280      /**
 281       * Manipulate the query to be used to evaluate if this is an Empty State to provide specific conditions for this extension.
 282       *
 283       * @return DatabaseQuery
 284       *
 285       * @since 4.0.0
 286       */
 287      protected function getEmptyStateQuery()
 288      {
 289          $query = parent::getEmptyStateQuery();
 290  
 291          $query->where($this->getDatabase()->quoteName('state') . ' = -1');
 292  
 293          return $query;
 294      }
 295  
 296      /**
 297       * Checks for not installed extensions in extensions table.
 298       *
 299       * @return  boolean  True if there are discovered extensions in the database.
 300       *
 301       * @since   4.2.0
 302       */
 303      public function checkExtensions()
 304      {
 305          $db    = $this->getDatabase();
 306          $query = $db->getQuery(true)
 307              ->select('*')
 308              ->from($db->quoteName('#__extensions'))
 309              ->where($db->quoteName('state') . ' = -1');
 310          $db->setQuery($query);
 311          $discoveredExtensions = $db->loadObjectList();
 312  
 313          return count($discoveredExtensions) > 0;
 314      }
 315  }