Source for file library.php

Documentation is available at library.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Libraries
  4.  * @subpackage  Installer
  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
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. jimport('joomla.base.adapterinstance');
  13. jimport('joomla.filesystem.folder');
  14.  
  15. /**
  16.  * Library installer
  17.  *
  18.  * @package     Joomla.Libraries
  19.  * @subpackage  Installer
  20.  * @since       3.1
  21.  */
  22. class JInstallerAdapterLibrary extends JAdapterInstance
  23. {
  24.     /**
  25.      * Custom loadLanguage method
  26.      *
  27.      * @param   string  $path  The path where to find language files.
  28.      *
  29.      * @return  void 
  30.      *
  31.      * @since   3.1
  32.      */
  33.     public function loadLanguage($path = null)
  34.     {
  35.         $source = $this->parent->getPath('source');
  36.  
  37.         if (!$source)
  38.         {
  39.             $this->parent->setPath('source', JPATH_PLATFORM . '/' . $this->parent->extension->element);
  40.         }
  41.         $this->manifest = $this->parent->getManifest();
  42.         $extension = 'lib_' . strtolower(JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd'));
  43.         $name = strtolower((string) $this->manifest->libraryname);
  44.         $lang = JFactory::getLanguage();
  45.         $source = $path ? $path : JPATH_PLATFORM . "/$name";
  46.         $lang->load($extension . '.sys', $source, null, false, true)
  47.             || $lang->load($extension . '.sys', JPATH_SITE, null, false, true);
  48.     }
  49.  
  50.     /**
  51.      * Custom install method
  52.      *
  53.      * @return  boolean  True on success
  54.      *
  55.      * @since   3.1
  56.      */
  57.     public function install()
  58.     {
  59.         // Get the extension manifest object
  60.         $this->manifest = $this->parent->getManifest();
  61.  
  62.         /*
  63.          * ---------------------------------------------------------------------------------------------
  64.          * Manifest Document Setup Section
  65.          * ---------------------------------------------------------------------------------------------
  66.          */
  67.  
  68.         // Set the extension's name
  69.         $name = JFilterInput::getInstance()->clean((string) $this->manifest->name, 'string');
  70.         $element = str_replace('.xml', '', basename($this->parent->getPath('manifest')));
  71.         $this->set('name', $name);
  72.         $this->set('element', $element);
  73.  
  74.         $db = $this->parent->getDbo();
  75.         $query = $db->getQuery(true)
  76.             ->select($db->quoteName('extension_id'))
  77.             ->from($db->quoteName('#__extensions'))
  78.             ->where($db->quoteName('type') . ' = ' . $db->quote('library'))
  79.             ->where($db->quoteName('element') . ' = ' . $db->quote($element));
  80.         $db->setQuery($query);
  81.         $result = $db->loadResult();
  82.  
  83.         if ($result)
  84.         {
  85.             // Already installed, can we upgrade?
  86.             if ($this->parent->isOverwrite() || $this->parent->isUpgrade())
  87.             {
  88.                 // We can upgrade, so uninstall the old one
  89.                 $installer = new JInstaller; // we don't want to compromise this instance!
  90.                 $installer->uninstall('library', $result);
  91.             }
  92.             else
  93.             {
  94.                 // Abort the install, no upgrade possible
  95.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_LIB_INSTALL_ALREADY_INSTALLED'));
  96.  
  97.                 return false;
  98.             }
  99.         }
  100.  
  101.         // Get the library's description
  102.         $description = (string) $this->manifest->description;
  103.  
  104.         if ($description)
  105.         {
  106.             $this->parent->set('message', JText::_($description));
  107.         }
  108.         else
  109.         {
  110.             $this->parent->set('message', '');
  111.         }
  112.  
  113.         // Set the installation path
  114.         $group = (string) $this->manifest->libraryname;
  115.  
  116.         if (!$group)
  117.         {
  118.             $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_LIB_INSTALL_NOFILE'));
  119.  
  120.             return false;
  121.         }
  122.         else
  123.         {
  124.             $this->parent->setPath('extension_root', JPATH_PLATFORM . '/' . implode(DIRECTORY_SEPARATOR, explode('/', $group)));
  125.         }
  126.  
  127.         /*
  128.          * ---------------------------------------------------------------------------------------------
  129.          * Filesystem Processing Section
  130.          * ---------------------------------------------------------------------------------------------
  131.          */
  132.  
  133.         // If the library directory does not exist, let's create it
  134.         $created = false;
  135.  
  136.         if (!file_exists($this->parent->getPath('extension_root')))
  137.         {
  138.             if (!$created = JFolder::create($this->parent->getPath('extension_root')))
  139.             {
  140.                 $this->parent->abort(
  141.                     JText::sprintf('JLIB_INSTALLER_ABORT_LIB_INSTALL_FAILED_TO_CREATE_DIRECTORY', $this->parent->getPath('extension_root'))
  142.                 );
  143.  
  144.                 return false;
  145.             }
  146.         }
  147.  
  148.         /*
  149.          * If we created the library directory and will want to remove it if we
  150.          * have to roll back the installation, let's add it to the installation
  151.          * step stack
  152.          */
  153.         if ($created)
  154.         {
  155.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_root')));
  156.         }
  157.  
  158.         // Copy all necessary files
  159.         if ($this->parent->parseFiles($this->manifest->files, -1) === false)
  160.         {
  161.             // Install failed, roll back changes
  162.             $this->parent->abort();
  163.  
  164.             return false;
  165.         }
  166.  
  167.         // Parse optional tags
  168.         $this->parent->parseLanguages($this->manifest->languages);
  169.         $this->parent->parseMedia($this->manifest->media);
  170.  
  171.         // Extension Registration
  172.         $row = JTable::getInstance('extension');
  173.         $row->name = $this->get('name');
  174.         $row->type = 'library';
  175.         $row->element = $this->get('element');
  176.  
  177.         // There is no folder for libraries
  178.         $row->folder = '';
  179.         $row->enabled = 1;
  180.         $row->protected = 0;
  181.         $row->access = 1;
  182.         $row->client_id = 0;
  183.         $row->params = $this->parent->getParams();
  184.  
  185.         // Custom data
  186.         $row->custom_data = '';
  187.         $row->manifest_cache = $this->parent->generateManifestCache();
  188.  
  189.         if (!$row->store())
  190.         {
  191.             // Install failed, roll back changes
  192.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_LIB_INSTALL_ROLLBACK', $db->stderr(true)));
  193.  
  194.             return false;
  195.         }
  196.  
  197.         /**
  198.          * ---------------------------------------------------------------------------------------------
  199.          * Finalization and Cleanup Section
  200.          * ---------------------------------------------------------------------------------------------
  201.          */
  202.  
  203.         // Lastly, we will copy the manifest file to its appropriate place.
  204.         $manifest = array();
  205.         $manifest['src'] = $this->parent->getPath('manifest');
  206.         $manifest['dest'] = JPATH_MANIFESTS . '/libraries/' . basename($this->parent->getPath('manifest'));
  207.  
  208.         if (!$this->parent->copyFiles(array($manifest), true))
  209.         {
  210.             // Install failed, rollback changes
  211.             $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_LIB_INSTALL_COPY_SETUP'));
  212.  
  213.             return false;
  214.         }
  215.         return $row->get('extension_id');
  216.     }
  217.  
  218.     /**
  219.      * Custom update method
  220.      *
  221.      * @return  boolean  True on success
  222.      *
  223.      * @since   3.1
  224.      */
  225.     public function update()
  226.     {
  227.         // Since this is just files, an update removes old files
  228.         // Get the extension manifest object
  229.         $this->manifest = $this->parent->getManifest();
  230.  
  231.         /*
  232.          * ---------------------------------------------------------------------------------------------
  233.          * Manifest Document Setup Section
  234.          * ---------------------------------------------------------------------------------------------
  235.          */
  236.  
  237.         // Set the extensions name
  238.         $name = (string) $this->manifest->name;
  239.         $name = JFilterInput::getInstance()->clean($name, 'string');
  240.         $element = str_replace('.xml', '', basename($this->parent->getPath('manifest')));
  241.         $this->set('name', $name);
  242.         $this->set('element', $element);
  243.  
  244.         // We don't want to compromise this instance!
  245.         $installer = new JInstaller;
  246.         $db = $this->parent->getDbo();
  247.         $query = $db->getQuery(true)
  248.             ->select($db->quoteName('extension_id'))
  249.             ->from($db->quoteName('#__extensions'))
  250.             ->where($db->quoteName('type') . ' = ' . $db->quote('library'))
  251.             ->where($db->quoteName('element') . ' = ' . $db->quote($element));
  252.         $db->setQuery($query);
  253.         $result = $db->loadResult();
  254.  
  255.         if ($result)
  256.         {
  257.             // Already installed, which would make sense
  258.             $installer->uninstall('library', $result);
  259.         }
  260.         // Now create the new files
  261.         return $this->install();
  262.     }
  263.  
  264.     /**
  265.      * Custom uninstall method
  266.      *
  267.      * @param   string  $id  The id of the library to uninstall.
  268.      *
  269.      * @return  boolean  True on success
  270.      *
  271.      * @since   3.1
  272.      */
  273.     public function uninstall($id)
  274.     {
  275.         $retval = true;
  276.  
  277.         // First order of business will be to load the module object table from the database.
  278.         // This should give us the necessary information to proceed.
  279.         $row = JTable::getInstance('extension');
  280.  
  281.         if (!$row->load((int) $id) || !strlen($row->element))
  282.         {
  283.             JLog::add(JText::_('ERRORUNKOWNEXTENSION'), JLog::WARNING, 'jerror');
  284.  
  285.             return false;
  286.         }
  287.  
  288.         // Is the library we are trying to uninstall a core one?
  289.         // Because that is not a good idea...
  290.         if ($row->protected)
  291.         {
  292.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LIB_UNINSTALL_WARNCORELIBRARY'), JLog::WARNING, 'jerror');
  293.  
  294.             return false;
  295.         }
  296.  
  297.         $manifestFile = JPATH_MANIFESTS . '/libraries/' . $row->element . '.xml';
  298.  
  299.         // Because libraries may not have their own folders we cannot use the standard method of finding an installation manifest
  300.         if (file_exists($manifestFile))
  301.         {
  302.             $manifest = new JInstallerManifestLibrary($manifestFile);
  303.  
  304.             // Set the library root path
  305.             $this->parent->setPath('extension_root', JPATH_PLATFORM . '/' . $manifest->libraryname);
  306.  
  307.             $xml = simplexml_load_file($manifestFile);
  308.  
  309.             // If we cannot load the XML file return null
  310.             if (!$xml)
  311.             {
  312.                 JLog::add(JText::_('JLIB_INSTALLER_ERROR_LIB_UNINSTALL_LOAD_MANIFEST'), JLog::WARNING, 'jerror');
  313.  
  314.                 return false;
  315.             }
  316.  
  317.             // Check for a valid XML root tag.
  318.             if ($xml->getName() != 'extension')
  319.             {
  320.                 JLog::add(JText::_('JLIB_INSTALLER_ERROR_LIB_UNINSTALL_INVALID_MANIFEST'), JLog::WARNING, 'jerror');
  321.  
  322.                 return false;
  323.             }
  324.  
  325.             $this->parent->removeFiles($xml->files, -1);
  326.             JFile::delete($manifestFile);
  327.  
  328.         }
  329.         else
  330.         {
  331.             // Remove this row entry since its invalid
  332.             $row->delete($row->extension_id);
  333.             unset($row);
  334.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LIB_UNINSTALL_INVALID_NOTFOUND_MANIFEST'), JLog::WARNING, 'jerror');
  335.  
  336.             return false;
  337.         }
  338.  
  339.         // TODO: Change this so it walked up the path backwards so we clobber multiple empties
  340.         // If the folder is empty, let's delete it
  341.         if (JFolder::exists($this->parent->getPath('extension_root')))
  342.         {
  343.             if (is_dir($this->parent->getPath('extension_root')))
  344.             {
  345.                 $files = JFolder::files($this->parent->getPath('extension_root'));
  346.  
  347.                 if (!count($files))
  348.                 {
  349.                     JFolder::delete($this->parent->getPath('extension_root'));
  350.                 }
  351.             }
  352.         }
  353.  
  354.         $this->parent->removeFiles($xml->media);
  355.         $this->parent->removeFiles($xml->languages);
  356.  
  357.         $row->delete($row->extension_id);
  358.         unset($row);
  359.  
  360.         return $retval;
  361.     }
  362.  
  363.     /**
  364.      * Custom discover method
  365.      *
  366.      * @return  array  JExtension  list of extensions available
  367.      *
  368.      * @since   3.1
  369.      */
  370.     public function discover()
  371.     {
  372.         $results = array();
  373.         $file_list = JFolder::files(JPATH_MANIFESTS . '/libraries', '\.xml$');
  374.  
  375.         foreach ($file_list as $file)
  376.         {
  377.             $manifest_details = JInstaller::parseXMLInstallFile(JPATH_MANIFESTS . '/libraries/' . $file);
  378.             $file = JFile::stripExt($file);
  379.             $extension = JTable::getInstance('extension');
  380.             $extension->set('type', 'library');
  381.             $extension->set('client_id', 0);
  382.             $extension->set('element', $file);
  383.             $extension->set('folder', '');
  384.             $extension->set('name', $file);
  385.             $extension->set('state', -1);
  386.             $extension->set('manifest_cache', json_encode($manifest_details));
  387.             $extension->set('params', '{}');
  388.             $results[] = $extension;
  389.         }
  390.         return $results;
  391.     }
  392.  
  393.     /**
  394.      * Custom discover_install method
  395.      *
  396.      * @return  boolean  True on success
  397.      *
  398.      * @since   3.1
  399.      */
  400.     public function discover_install()
  401.     {
  402.         /* Libraries are a strange beast; they are actually references to files
  403.          * There are two parts to a library which are disjunct in their locations
  404.          * 1) The manifest file (stored in /JPATH_MANIFESTS/libraries)
  405.          * 2) The actual files (stored in /JPATH_PLATFORM/libraryname)
  406.          * Thus installation of a library is the process of dumping files
  407.          * in two different places. As such it is impossible to perform
  408.          * any operation beyond mere registration of a library under the presumption
  409.          * that the files exist in the appropriate location so that come uninstall
  410.          * time they can be adequately removed.
  411.          */
  412.  
  413.         $manifestPath = JPATH_MANIFESTS . '/libraries/' . $this->parent->extension->element . '.xml';
  414.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  415.         $this->parent->setPath('manifest', $manifestPath);
  416.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  417.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  418.         $this->parent->extension->state = 0;
  419.         $this->parent->extension->name = $manifest_details['name'];
  420.         $this->parent->extension->enabled = 1;
  421.         $this->parent->extension->params = $this->parent->getParams();
  422.  
  423.         if ($this->parent->extension->store())
  424.         {
  425.             return true;
  426.         }
  427.         else
  428.         {
  429.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LIB_DISCOVER_STORE_DETAILS'), JLog::WARNING, 'jerror');
  430.  
  431.             return false;
  432.         }
  433.     }
  434.  
  435.     /**
  436.      * Refreshes the extension table cache
  437.      *
  438.      * @return  boolean  Result of operation, true if updated, false on failure
  439.      *
  440.      * @since   3.1
  441.      */
  442.     public function refreshManifestCache()
  443.     {
  444.         // Need to find to find where the XML file is since we don't store this normally
  445.         $manifestPath = JPATH_MANIFESTS . '/libraries/' . $this->parent->extension->element . '.xml';
  446.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  447.         $this->parent->setPath('manifest', $manifestPath);
  448.  
  449.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  450.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  451.         $this->parent->extension->name = $manifest_details['name'];
  452.  
  453.         try
  454.         {
  455.             return $this->parent->extension->store();
  456.         }
  457.         catch (RuntimeException $e)
  458.         {
  459.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LIB_REFRESH_MANIFEST_CACHE'), JLog::WARNING, 'jerror');
  460.  
  461.             return false;
  462.         }
  463.     }
  464. }
  465.  
  466. /**
  467.  * Deprecated class placeholder. You should use JInstallerAdapterLibrary instead.
  468.  *
  469.  * @package     Joomla.Libraries
  470.  * @subpackage  Installer
  471.  * @since       3.1
  472.  * @deprecated  4.0
  473.  * @codeCoverageIgnore
  474.  */
  475. class JInstallerLibrary extends JInstallerAdapterLibrary
  476. {
  477. }

Documentation generated on Tue, 19 Nov 2013 15:07:05 +0100 by phpDocumentor 1.4.3