Source for file language.php

Documentation is available at language.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.  * Language installer
  17.  *
  18.  * @package     Joomla.Libraries
  19.  * @subpackage  Installer
  20.  * @since       3.1
  21.  */
  22. class JInstallerAdapterLanguage extends JAdapterInstance
  23. {
  24.     /**
  25.      * Core language pack flag
  26.      *
  27.      * @var    boolean 
  28.      * @since  12.1
  29.      */
  30.     protected $core = false;
  31.  
  32.     /**
  33.      * Custom install method
  34.      *
  35.      * Note: This behaves badly due to hacks made in the middle of 1.5.x to add
  36.      * the ability to install multiple distinct packs in one install. The
  37.      * preferred method is to use a package to install multiple language packs.
  38.      *
  39.      * @return  boolean  True on success
  40.      *
  41.      * @since   3.1
  42.      */
  43.     public function install()
  44.     {
  45.         $source = $this->parent->getPath('source');
  46.  
  47.         if (!$source)
  48.         {
  49.             $this->parent
  50.                 ->setPath(
  51.                 'source',
  52.                 ($this->parent->extension->client_id ? JPATH_ADMINISTRATOR : JPATH_SITE) . '/language/' . $this->parent->extension->element
  53.             );
  54.         }
  55.         $this->manifest = $this->parent->getManifest();
  56.  
  57.         // Get the client application target
  58.         if ($cname = (string) $this->manifest->attributes()->client)
  59.         {
  60.             // Attempt to map the client to a base path
  61.             $client = JApplicationHelper::getClientInfo($cname, true);
  62.  
  63.             if ($client === null)
  64.             {
  65.                 $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT', JText::sprintf('JLIB_INSTALLER_ERROR_UNKNOWN_CLIENT_TYPE', $cname)));
  66.  
  67.                 return false;
  68.             }
  69.             $basePath = $client->path;
  70.             $clientId = $client->id;
  71.             $element = $this->manifest->files;
  72.  
  73.             return $this->_install($cname, $basePath, $clientId, $element);
  74.         }
  75.         else
  76.         {
  77.             // No client attribute was found so we assume the site as the client
  78.             $cname = 'site';
  79.             $basePath = JPATH_SITE;
  80.             $clientId = 0;
  81.             $element = $this->manifest->files;
  82.  
  83.             return $this->_install($cname, $basePath, $clientId, $element);
  84.         }
  85.     }
  86.  
  87.     /**
  88.      * Install function that is designed to handle individual clients
  89.      *
  90.      * @param   string   $cname     Cname @todo: not used
  91.      * @param   string   $basePath  The base name.
  92.      * @param   integer  $clientId  The client id.
  93.      * @param   object   &$element  The XML element.
  94.      *
  95.      * @return  boolean 
  96.      *
  97.      * @since  3.1
  98.      */
  99.     protected function _install($cname, $basePath, $clientId, &$element)
  100.     {
  101.         $this->manifest = $this->parent->getManifest();
  102.  
  103.         // Get the language name
  104.         // Set the extensions name
  105.         $name = JFilterInput::getInstance()->clean((string) $this->manifest->name, 'cmd');
  106.         $this->set('name', $name);
  107.  
  108.         // Get the Language tag [ISO tag, eg. en-GB]
  109.         $tag = (string) $this->manifest->tag;
  110.  
  111.         // Check if we found the tag - if we didn't, we may be trying to install from an older language package
  112.         if (!$tag)
  113.         {
  114.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT', JText::_('JLIB_INSTALLER_ERROR_NO_LANGUAGE_TAG')));
  115.  
  116.             return false;
  117.         }
  118.  
  119.         $this->set('tag', $tag);
  120.  
  121.         // Set the language installation path
  122.         $this->parent->setPath('extension_site', $basePath . '/language/' . $tag);
  123.  
  124.         // Do we have a meta file in the file list?  In other words... is this a core language pack?
  125.         if ($element && count($element->children()))
  126.         {
  127.             $files = $element->children();
  128.  
  129.             foreach ($files as $file)
  130.             {
  131.                 if ((string) $file->attributes()->file == 'meta')
  132.                 {
  133.                     $this->core = true;
  134.                     break;
  135.                 }
  136.             }
  137.         }
  138.  
  139.         // If the language directory does not exist, let's create it
  140.         $created = false;
  141.  
  142.         if (!file_exists($this->parent->getPath('extension_site')))
  143.         {
  144.             if (!$created = JFolder::create($this->parent->getPath('extension_site')))
  145.             {
  146.                 $this->parent
  147.                     ->abort(
  148.                     JText::sprintf(
  149.                         'JLIB_INSTALLER_ABORT',
  150.                         JText::sprintf('JLIB_INSTALLER_ERROR_CREATE_FOLDER_FAILED', $this->parent->getPath('extension_site'))
  151.                     )
  152.                 );
  153.  
  154.                 return false;
  155.             }
  156.         }
  157.         else
  158.         {
  159.             // Look for an update function or update tag
  160.             $updateElement = $this->manifest->update;
  161.  
  162.             // Upgrade manually set or update tag detected
  163.             if ($this->parent->isUpgrade() || $updateElement)
  164.             {
  165.                 // Transfer control to the update function
  166.                 return $this->update();
  167.             }
  168.             elseif (!$this->parent->isOverwrite())
  169.             {
  170.                 // Overwrite is set
  171.                 // We didn't have overwrite set, find an update function or find an update tag so lets call it safe
  172.                 if (file_exists($this->parent->getPath('extension_site')))
  173.                 {
  174.                     // If the site exists say so.
  175.                     JLog::add(
  176.                         JText::sprintf('JLIB_INSTALLER_ABORT', JText::sprintf('JLIB_INSTALLER_ERROR_FOLDER_IN_USE', $this->parent->getPath('extension_site'))),
  177.                         JLog::WARNING, 'jerror'
  178.                     );
  179.                 }
  180.                 else
  181.                 {
  182.                     // If the admin exists say so.
  183.                     JLog::add(
  184.                         JText::sprintf('JLIB_INSTALLER_ABORT', JText::sprintf('JLIB_INSTALLER_ERROR_FOLDER_IN_USE', $this->parent->getPath('extension_administrator'))),
  185.                         JLog::WARNING, 'jerror'
  186.                     );
  187.                 }
  188.                 return false;
  189.             }
  190.         }
  191.  
  192.         /*
  193.          * If we created the language directory we will want to remove it if we
  194.          * have to roll back the installation, so let's add it to the installation
  195.          * step stack
  196.          */
  197.         if ($created)
  198.         {
  199.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_site')));
  200.         }
  201.  
  202.         // Copy all the necessary files
  203.         if ($this->parent->parseFiles($element) === false)
  204.         {
  205.             // Install failed, rollback changes
  206.             $this->parent->abort();
  207.  
  208.             return false;
  209.         }
  210.  
  211.         // Parse optional tags
  212.         $this->parent->parseMedia($this->manifest->media);
  213.  
  214.         // Copy all the necessary font files to the common pdf_fonts directory
  215.         $this->parent->setPath('extension_site', $basePath . '/language/pdf_fonts');
  216.         $overwrite = $this->parent->setOverwrite(true);
  217.  
  218.         if ($this->parent->parseFiles($this->manifest->fonts) === false)
  219.         {
  220.             // Install failed, rollback changes
  221.             $this->parent->abort();
  222.  
  223.             return false;
  224.         }
  225.         $this->parent->setOverwrite($overwrite);
  226.  
  227.         // Get the language description
  228.         $description = (string) $this->manifest->description;
  229.  
  230.         if ($description)
  231.         {
  232.             $this->parent->set('message', JText::_($description));
  233.         }
  234.         else
  235.         {
  236.             $this->parent->set('message', '');
  237.         }
  238.  
  239.         // Add an entry to the extension table with a whole heap of defaults
  240.         $row = JTable::getInstance('extension');
  241.         $row->set('name', $this->get('name'));
  242.         $row->set('type', 'language');
  243.         $row->set('element', $this->get('tag'));
  244.  
  245.         // There is no folder for languages
  246.         $row->set('folder', '');
  247.         $row->set('enabled', 1);
  248.         $row->set('protected', 0);
  249.         $row->set('access', 0);
  250.         $row->set('client_id', $clientId);
  251.         $row->set('params', $this->parent->getParams());
  252.         $row->set('manifest_cache', $this->parent->generateManifestCache());
  253.  
  254.         if (!$row->store())
  255.         {
  256.             // Install failed, roll back changes
  257.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT', $row->getError()));
  258.  
  259.             return false;
  260.         }
  261.  
  262.         // Clobber any possible pending updates
  263.         $update = JTable::getInstance('update');
  264.         $uid = $update->find(array('element' => $this->get('tag'), 'type' => 'language', 'client_id' => '', 'folder' => ''));
  265.  
  266.         if ($uid)
  267.         {
  268.             $update->delete($uid);
  269.         }
  270.  
  271.         return $row->get('extension_id');
  272.     }
  273.  
  274.     /**
  275.      * Custom update method
  276.      *
  277.      * @return  boolean  True on success, false on failure
  278.      *
  279.      * @since   3.1
  280.      */
  281.     public function update()
  282.     {
  283.         $xml = $this->parent->getManifest();
  284.  
  285.         $this->manifest = $xml;
  286.  
  287.         $cname = $xml->attributes()->client;
  288.  
  289.         // Attempt to map the client to a base path
  290.         $client = JApplicationHelper::getClientInfo($cname, true);
  291.  
  292.         if ($client === null || (empty($cname) && $cname !== 0))
  293.         {
  294.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT', JText::sprintf('JLIB_INSTALLER_ERROR_UNKNOWN_CLIENT_TYPE', $cname)));
  295.  
  296.             return false;
  297.         }
  298.         $basePath = $client->path;
  299.         $clientId = $client->id;
  300.  
  301.         // Get the language name
  302.         // Set the extensions name
  303.         $name = (string) $this->manifest->name;
  304.         $name = JFilterInput::getInstance()->clean($name, 'cmd');
  305.         $this->set('name', $name);
  306.  
  307.         // Get the Language tag [ISO tag, eg. en-GB]
  308.         $tag = (string) $xml->tag;
  309.  
  310.         // Check if we found the tag - if we didn't, we may be trying to install from an older language package
  311.         if (!$tag)
  312.         {
  313.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT', JText::_('JLIB_INSTALLER_ERROR_NO_LANGUAGE_TAG')));
  314.  
  315.             return false;
  316.         }
  317.  
  318.         $this->set('tag', $tag);
  319.  
  320.         // Set the language installation path
  321.         $this->parent->setPath('extension_site', $basePath . '/language/' . $tag);
  322.  
  323.         // Do we have a meta file in the file list?  In other words... is this a core language pack?
  324.         if (count($xml->files->children()))
  325.         {
  326.             foreach ($xml->files->children() as $file)
  327.             {
  328.                 if ((string) $file->attributes()->file == 'meta')
  329.                 {
  330.                     $this->core = true;
  331.                     break;
  332.                 }
  333.             }
  334.         }
  335.  
  336.         // Copy all the necessary files
  337.         if ($this->parent->parseFiles($xml->files) === false)
  338.         {
  339.             // Install failed, rollback changes
  340.             $this->parent->abort();
  341.  
  342.             return false;
  343.         }
  344.  
  345.         // Parse optional tags
  346.         $this->parent->parseMedia($xml->media);
  347.  
  348.         // Copy all the necessary font files to the common pdf_fonts directory
  349.         $this->parent->setPath('extension_site', $basePath . '/language/pdf_fonts');
  350.         $overwrite = $this->parent->setOverwrite(true);
  351.  
  352.         if ($this->parent->parseFiles($xml->fonts) === false)
  353.         {
  354.             // Install failed, rollback changes
  355.             $this->parent->abort();
  356.  
  357.             return false;
  358.         }
  359.         $this->parent->setOverwrite($overwrite);
  360.  
  361.         // Get the language description and set it as message
  362.         $this->parent->set('message', (string) $xml->description);
  363.  
  364.         /**
  365.          * ---------------------------------------------------------------------------------------------
  366.          * Finalization and Cleanup Section
  367.          * ---------------------------------------------------------------------------------------------
  368.          */
  369.  
  370.         // Clobber any possible pending updates
  371.         $update = JTable::getInstance('update');
  372.         $uid = $update->find(array('element' => $this->get('tag'), 'type' => 'language', 'client_id' => $clientId));
  373.  
  374.         if ($uid)
  375.         {
  376.             $update->delete($uid);
  377.         }
  378.  
  379.         // Update an entry to the extension table
  380.         $row = JTable::getInstance('extension');
  381.         $eid = $row->find(array('element' => strtolower($this->get('tag')), 'type' => 'language', 'client_id' => $clientId));
  382.  
  383.         if ($eid)
  384.         {
  385.             $row->load($eid);
  386.         }
  387.         else
  388.         {
  389.             // Set the defaults
  390.  
  391.             // There is no folder for language
  392.             $row->set('folder', '');
  393.             $row->set('enabled', 1);
  394.             $row->set('protected', 0);
  395.             $row->set('access', 0);
  396.             $row->set('client_id', $clientId);
  397.             $row->set('params', $this->parent->getParams());
  398.         }
  399.         $row->set('name', $this->get('name'));
  400.         $row->set('type', 'language');
  401.         $row->set('element', $this->get('tag'));
  402.         $row->set('manifest_cache', $this->parent->generateManifestCache());
  403.  
  404.         if (!$row->store())
  405.         {
  406.             // Install failed, roll back changes
  407.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT', $row->getError()));
  408.  
  409.             return false;
  410.         }
  411.  
  412.         return $row->get('extension_id');
  413.     }
  414.  
  415.     /**
  416.      * Custom uninstall method
  417.      *
  418.      * @param   string  $eid  The tag of the language to uninstall
  419.      *
  420.      * @return  mixed  Return value for uninstall method in component uninstall file
  421.      *
  422.      * @since   3.1
  423.      */
  424.     public function uninstall($eid)
  425.     {
  426.         // Load up the extension details
  427.         $extension = JTable::getInstance('extension');
  428.         $extension->load($eid);
  429.  
  430.         // Grab a copy of the client details
  431.         $client = JApplicationHelper::getClientInfo($extension->get('client_id'));
  432.  
  433.         // Check the element isn't blank to prevent nuking the languages directory...just in case
  434.         $element = $extension->get('element');
  435.  
  436.         if (empty($element))
  437.         {
  438.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LANG_UNINSTALL_ELEMENT_EMPTY'), JLog::WARNING, 'jerror');
  439.  
  440.             return false;
  441.         }
  442.  
  443.         // Check that the language is not protected, Normally en-GB.
  444.         $protected = $extension->get('protected');
  445.  
  446.         if ($protected == 1)
  447.         {
  448.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LANG_UNINSTALL_PROTECTED'), JLog::WARNING, 'jerror');
  449.  
  450.             return false;
  451.         }
  452.  
  453.         // Verify that it's not the default language for that client
  454.         $params = JComponentHelper::getParams('com_languages');
  455.  
  456.         if ($params->get($client->name) == $element)
  457.         {
  458.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LANG_UNINSTALL_DEFAULT'), JLog::WARNING, 'jerror');
  459.  
  460.             return false;
  461.         }
  462.  
  463.         // Construct the path from the client, the language and the extension element name
  464.         $path = $client->path . '/language/' . $element;
  465.  
  466.         // Get the package manifest object and remove media
  467.         $this->parent->setPath('source', $path);
  468.  
  469.         // We do findManifest to avoid problem when uninstalling a list of extension: getManifest cache its manifest file
  470.         $this->parent->findManifest();
  471.         $this->manifest = $this->parent->getManifest();
  472.         $this->parent->removeFiles($this->manifest->media);
  473.  
  474.         // Check it exists
  475.         if (!JFolder::exists($path))
  476.         {
  477.             // If the folder doesn't exist lets just nuke the row as well and presume the user killed it for us
  478.             $extension->delete();
  479.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LANG_UNINSTALL_PATH_EMPTY'), JLog::WARNING, 'jerror');
  480.  
  481.             return false;
  482.         }
  483.  
  484.         if (!JFolder::delete($path))
  485.         {
  486.             // If deleting failed we'll leave the extension entry in tact just in case
  487.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LANG_UNINSTALL_DIRECTORY'), JLog::WARNING, 'jerror');
  488.  
  489.             return false;
  490.         }
  491.  
  492.         // Remove the extension table entry
  493.         $extension->delete();
  494.  
  495.         // Setting the language of users which have this language as the default language
  496.         $db = JFactory::getDbo();
  497.         $query = $db->getQuery(true)
  498.             ->from('#__users')
  499.             ->select('*');
  500.         $db->setQuery($query);
  501.         $users = $db->loadObjectList();
  502.  
  503.         if ($client->name == 'administrator')
  504.         {
  505.             $param_name = 'admin_language';
  506.         }
  507.         else
  508.         {
  509.             $param_name = 'language';
  510.         }
  511.  
  512.         $count = 0;
  513.  
  514.         foreach ($users as $user)
  515.         {
  516.             $registry = new JRegistry;
  517.             $registry->loadString($user->params);
  518.  
  519.             if ($registry->get($param_name) == $element)
  520.             {
  521.                 $registry->set($param_name, '');
  522.                 $query->clear()
  523.                     ->update('#__users')
  524.                     ->set('params=' . $db->quote($registry))
  525.                     ->where('id=' . (int) $user->id);
  526.                 $db->setQuery($query);
  527.                 $db->execute();
  528.                 $count++;
  529.             }
  530.         }
  531.         if (!empty($count))
  532.         {
  533.             JLog::add(JText::plural('JLIB_INSTALLER_NOTICE_LANG_RESET_USERS', $count), JLog::NOTICE, 'jerror');
  534.         }
  535.  
  536.         // All done!
  537.         return true;
  538.     }
  539.  
  540.     /**
  541.      * Custom discover method
  542.      * Finds language files
  543.      *
  544.      * @return  boolean  True on success
  545.      *
  546.      * @since  3.1
  547.      */
  548.     public function discover()
  549.     {
  550.         $results = array();
  551.         $site_languages = JFolder::folders(JPATH_SITE . '/language');
  552.         $admin_languages = JFolder::folders(JPATH_ADMINISTRATOR . '/language');
  553.  
  554.         foreach ($site_languages as $language)
  555.         {
  556.             if (file_exists(JPATH_SITE . '/language/' . $language . '/' . $language . '.xml'))
  557.             {
  558.                 $manifest_details = JInstaller::parseXMLInstallFile(JPATH_SITE . '/language/' . $language . '/' . $language . '.xml');
  559.                 $extension = JTable::getInstance('extension');
  560.                 $extension->set('type', 'language');
  561.                 $extension->set('client_id', 0);
  562.                 $extension->set('element', $language);
  563.                 $extension->set('folder', '');
  564.                 $extension->set('name', $language);
  565.                 $extension->set('state', -1);
  566.                 $extension->set('manifest_cache', json_encode($manifest_details));
  567.                 $extension->set('params', '{}');
  568.                 $results[] = $extension;
  569.             }
  570.         }
  571.         foreach ($admin_languages as $language)
  572.         {
  573.             if (file_exists(JPATH_ADMINISTRATOR . '/language/' . $language . '/' . $language . '.xml'))
  574.             {
  575.                 $manifest_details = JInstaller::parseXMLInstallFile(JPATH_ADMINISTRATOR . '/language/' . $language . '/' . $language . '.xml');
  576.                 $extension = JTable::getInstance('extension');
  577.                 $extension->set('type', 'language');
  578.                 $extension->set('client_id', 1);
  579.                 $extension->set('element', $language);
  580.                 $extension->set('folder', '');
  581.                 $extension->set('name', $language);
  582.                 $extension->set('state', -1);
  583.                 $extension->set('manifest_cache', json_encode($manifest_details));
  584.                 $extension->set('params', '{}');
  585.                 $results[] = $extension;
  586.             }
  587.         }
  588.         return $results;
  589.     }
  590.  
  591.     /**
  592.      * Custom discover install method
  593.      * Basically updates the manifest cache and leaves everything alone
  594.      *
  595.      * @return  integer  The extension id
  596.      *
  597.      * @since   3.1
  598.      */
  599.     public function discover_install()
  600.     {
  601.         // Need to find to find where the XML file is since we don't store this normally
  602.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  603.         $short_element = $this->parent->extension->element;
  604.         $manifestPath = $client->path . '/language/' . $short_element . '/' . $short_element . '.xml';
  605.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  606.         $this->parent->setPath('manifest', $manifestPath);
  607.         $this->parent->setPath('source', $client->path . '/language/' . $short_element);
  608.         $this->parent->setPath('extension_root', $this->parent->getPath('source'));
  609.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  610.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  611.         $this->parent->extension->state = 0;
  612.         $this->parent->extension->name = $manifest_details['name'];
  613.         $this->parent->extension->enabled = 1;
  614.  
  615.         // @todo remove code: $this->parent->extension->params = $this->parent->getParams();
  616.         try
  617.         {
  618.             $this->parent->extension->store();
  619.         }
  620.         catch (RuntimeException $e)
  621.         {
  622.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_LANG_DISCOVER_STORE_DETAILS'), JLog::WARNING, 'jerror');
  623.  
  624.             return false;
  625.         }
  626.         return $this->parent->extension->get('extension_id');
  627.     }
  628.  
  629.     /**
  630.      * Refreshes the extension table cache
  631.      *
  632.      * @return  boolean result of operation, true if updated, false on failure
  633.      *
  634.      * @since   3.1
  635.      */
  636.     public function refreshManifestCache()
  637.     {
  638.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  639.         $manifestPath = $client->path . '/language/' . $this->parent->extension->element . '/' . $this->parent->extension->element . '.xml';
  640.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  641.         $this->parent->setPath('manifest', $manifestPath);
  642.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  643.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  644.         $this->parent->extension->name = $manifest_details['name'];
  645.  
  646.         if ($this->parent->extension->store())
  647.         {
  648.             return true;
  649.         }
  650.         else
  651.         {
  652.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_MOD_REFRESH_MANIFEST_CACHE'), JLog::WARNING, 'jerror');
  653.  
  654.             return false;
  655.         }
  656.     }
  657. }
  658.  
  659. /**
  660.  * Deprecated class placeholder. You should use JInstallerAdapterLanguage instead.
  661.  *
  662.  * @package     Joomla.Libraries
  663.  * @subpackage  Installer
  664.  * @since       3.1
  665.  * @deprecated  4.0
  666.  * @codeCoverageIgnore
  667.  */
  668. class JInstallerLanguage extends JInstallerAdapterLanguage
  669. {
  670. }

Documentation generated on Tue, 19 Nov 2013 15:06:29 +0100 by phpDocumentor 1.4.3