Source for file languages.php

Documentation is available at languages.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Installation
  4.  * @subpackage  Model
  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. jimport('joomla.updater.update');
  13. jimport('legacy.component.helper');
  14.  
  15. /**
  16.  * Language Installer model for the Joomla Core Installer.
  17.  *
  18.  * @package     Joomla.Installation
  19.  * @subpackage  Model
  20.  * @since       3.1
  21.  */
  22. class InstallationModelLanguages extends JModelBase
  23. {
  24.     /**
  25.      * @var    object  Client object
  26.      * @since  3.1
  27.      */
  28.     protected $client = null;
  29.  
  30.     /**
  31.      * @var    array  Languages description
  32.      * @since  3.1
  33.      */
  34.     protected $data = null;
  35.  
  36.     /**
  37.      * @var    string  Language path
  38.      * @since  3.1
  39.      */
  40.     protected $path = null;
  41.  
  42.     /**
  43.      * @var    integer  Total number of languages installed
  44.      * @since  3.1
  45.      */
  46.     protected $langlist = null;
  47.  
  48.     /**
  49.      * @var    Admin Id, author of all generated content
  50.      * @since  3.1
  51.      */
  52.     protected $adminId = null;
  53.  
  54.     /**
  55.      * Constructor: Deletes the default installation config file and recreates it with the good config file.
  56.      *
  57.      * @since  3.1
  58.      */
  59.     public function __construct()
  60.     {
  61.         // Overrides application config and set the configuration.php file so tokens and database works
  62.         JFactory::$config = null;
  63.         JFactory::getConfig(JPATH_SITE . '/configuration.php');
  64.         JFactory::$session = null;
  65.  
  66.         parent::__construct();
  67.     }
  68.  
  69.     /**
  70.      * Generate a list of language choices to install in the Joomla CMS
  71.      *
  72.      * @return  boolean  True if successful
  73.      *
  74.      * @since   3.1
  75.      */
  76.     public function getItems()
  77.     {
  78.         $updater = JUpdater::getInstance();
  79.  
  80.         /*
  81.          * The following function uses extension_id 600, that is the English language extension id.
  82.          * In #__update_sites_extensions you should have 600 linked to the Accredited Translations Repo
  83.          */
  84.         $updater->findUpdates(array(600), 0);
  85.  
  86.         $db    = JFactory::getDbo();
  87.         $query = $db->getQuery(true);
  88.  
  89.         // Select the required fields from the updates table
  90.         $query->select('update_id, name, version')
  91.             ->from('#__updates')
  92.             ->order('name');
  93.  
  94.         $db->setQuery($query);
  95.         $list = $db->loadObjectList();
  96.  
  97.         if (!$list || $list instanceof Exception)
  98.         {
  99.             $list = array();
  100.         }
  101.  
  102.         return $list;
  103.     }
  104.  
  105.     /**
  106.      * Method that installs in Joomla! the selected languages in the Languages View of the installer.
  107.      *
  108.      * @param   array  $lids  List of the update_id value of the languages to install
  109.      *
  110.      * @return  boolean True if successful
  111.      */
  112.     public function install($lids)
  113.     {
  114.         /* @var InstallationApplicationWeb $app */
  115.         $app       = JFactory::getApplication();
  116.         $installer = JInstaller::getInstance();
  117.  
  118.         // Loop through every selected language
  119.         foreach ($lids as $id)
  120.         {
  121.             // Loads the update database object that represents the language
  122.             $language = JTable::getInstance('update');
  123.             $language->load($id);
  124.  
  125.             // Get the url to the XML manifest file of the selected language
  126.             $remote_manifest = $this->getLanguageManifest($id);
  127.  
  128.             if (!$remote_manifest)
  129.             {
  130.                 // Could not find the url, the information in the update server may be corrupt
  131.                 $message = JText::sprintf('INSTL_DEFAULTLANGUAGE_COULD_NOT_INSTALL_LANGUAGE', $language->name);
  132.                 $message .= ' ' . JText::_('INSTL_DEFAULTLANGUAGE_TRY_LATER');
  133.                 $app->enqueueMessage($message);
  134.                 continue;
  135.             }
  136.  
  137.             // Based on the language XML manifest get the url of the package to download
  138.             $package_url = $this->getPackageUrl($remote_manifest);
  139.  
  140.             if (!$package_url)
  141.             {
  142.                 // Could not find the url , maybe the url is wrong in the update server, or there is not internet access
  143.                 $message = JText::sprintf('INSTL_DEFAULTLANGUAGE_COULD_NOT_INSTALL_LANGUAGE', $language->name);
  144.                 $message .= ' ' . JText::_('INSTL_DEFAULTLANGUAGE_TRY_LATER');
  145.                 $app->enqueueMessage($message);
  146.                 continue;
  147.             }
  148.  
  149.             // Download the package to the tmp folder
  150.             $package = $this->downloadPackage($package_url);
  151.  
  152.             // Install the package
  153.             if (!$installer->install($package['dir']))
  154.             {
  155.                 // There was an error installing the package
  156.                 $message = JText::sprintf('INSTL_DEFAULTLANGUAGE_COULD_NOT_INSTALL_LANGUAGE', $language->name);
  157.                 $message .= ' ' . JText::_('INSTL_DEFAULTLANGUAGE_TRY_LATER');
  158.                 $app->enqueueMessage($message);
  159.                 continue;
  160.             }
  161.  
  162.             // Cleanup the install files in tmp folder
  163.             if (!is_file($package['packagefile']))
  164.             {
  165.                 $config                 = JFactory::getConfig();
  166.                 $package['packagefile'] = $config->get('tmp_path') . '/' . $package['packagefile'];
  167.             }
  168.  
  169.             JInstallerHelper::cleanupInstall($package['packagefile'], $package['extractdir']);
  170.  
  171.             // Delete the installed language from the list
  172.             $language->delete($id);
  173.         }
  174.  
  175.         return true;
  176.     }
  177.  
  178.     /**
  179.      * Gets the manifest file of a selected language from a the language list in a update server.
  180.      *
  181.      * @param   integer  $uid  The id of the language in the #__updates table
  182.      *
  183.      * @return  string 
  184.      *
  185.      * @since   3.1
  186.      */
  187.     protected function getLanguageManifest($uid)
  188.     {
  189.         $instance = JTable::getInstance('update');
  190.         $instance->load($uid);
  191.         $detailurl = trim($instance->detailsurl);
  192.  
  193.         return $detailurl;
  194.     }
  195.  
  196.     /**
  197.      * Finds the url of the package to download.
  198.      *
  199.      * @param   string  $remote_manifest  Url to the manifest XML file of the remote package
  200.      *
  201.      * @return  string|bool
  202.      *
  203.      * @since   3.1
  204.      */
  205.     protected function getPackageUrl($remote_manifest)
  206.     {
  207.         $update = new JUpdate;
  208.         $update->loadFromXML($remote_manifest);
  209.         $package_url = trim($update->get('downloadurl', false)->_data);
  210.  
  211.         return $package_url;
  212.     }
  213.  
  214.     /**
  215.      * Download a language package from a URL and unpack it in the tmp folder.
  216.      *
  217.      * @param   string  $url  Url of the package
  218.      *
  219.      * @return  array|boolPackage details or false on failure
  220.      *
  221.      * @since   3.1
  222.      */
  223.     protected function downloadPackage($url)
  224.     {
  225.         // Download the package from the given URL
  226.         $p_file = JInstallerHelper::downloadPackage($url);
  227.  
  228.         // Was the package downloaded?
  229.         if (!$p_file)
  230.         {
  231.             JFactory::getApplication()->enqueueMessage(JText::_('COM_INSTALLER_MSG_INSTALL_INVALID_URL'), 'warning');
  232.  
  233.             return false;
  234.         }
  235.  
  236.         $config   = JFactory::getConfig();
  237.         $tmp_dest = $config->get('tmp_path');
  238.  
  239.         // Unpack the downloaded package file
  240.         $package = JInstallerHelper::unpack($tmp_dest . '/' . $p_file);
  241.  
  242.         return $package;
  243.     }
  244.  
  245.     /**
  246.      * Get Languages item data for the Administrator
  247.      *
  248.      * @return  array 
  249.      *
  250.      * @since   3.1
  251.      */
  252.     public function getInstalledlangsAdministrator()
  253.     {
  254.         return $this->getInstalledlangs('administrator');
  255.     }
  256.  
  257.     /**
  258.      * Get Languages item data for the Frontend
  259.      *
  260.      * @return  array  List of installed languages in the frontend application
  261.      *
  262.      * @since   3.1
  263.      */
  264.     public function getInstalledlangsFrontend()
  265.     {
  266.         return $this->getInstalledlangs('site');
  267.     }
  268.  
  269.     /**
  270.      * Get Languages item data
  271.      *
  272.      * @param   string  $cms_client  Name of the cms client
  273.      *
  274.      * @return  array 
  275.      *
  276.      * @since   3.1
  277.      */
  278.     protected function getInstalledlangs($cms_client = 'administrator')
  279.     {
  280.         // Get information
  281.         $path     = $this->getPath();
  282.         $client   = $this->getClient($cms_client);
  283.         $langlist = $this->getLanguageList($client->id);
  284.  
  285.         // Compute all the languages
  286.         $data = array();
  287.  
  288.         foreach ($langlist as $lang)
  289.         {
  290.             $file          = $path . '/' . $lang . '/' . $lang . '.xml';
  291.             $info          = JInstaller::parseXMLInstallFile($file);
  292.             $row           = new stdClass;
  293.             $row->language = $lang;
  294.  
  295.             if (!is_array($info))
  296.             {
  297.                 continue;
  298.             }
  299.  
  300.             foreach ($info as $key => $value)
  301.             {
  302.                 $row->$key = $value;
  303.             }
  304.  
  305.             // If current then set published
  306.             $params = JComponentHelper::getParams('com_languages');
  307.  
  308.             if ($params->get($client->name, 'en-GB') == $row->language)
  309.             {
  310.                 $row->published = 1;
  311.             }
  312.             else
  313.             {
  314.                 $row->published = 0;
  315.             }
  316.  
  317.             $row->checked_out = 0;
  318.             $data[]           = $row;
  319.         }
  320.  
  321.         usort($data, array($this, 'compareLanguages'));
  322.  
  323.         return $data;
  324.     }
  325.  
  326.     /**
  327.      * Get installed languages data.
  328.      *
  329.      * @param   integer  $client_id  The client ID to retrieve data for
  330.      *
  331.      * @return  object  The language data
  332.      *
  333.      * @since   3.1
  334.      */
  335.     protected function getLanguageList($client_id = 1)
  336.     {
  337.         // Create a new db object.
  338.         $db    = JFactory::getDbo();
  339.         $query = $db->getQuery(true);
  340.  
  341.         // Select field element from the extensions table.
  342.         $query->select('a.element, a.name')
  343.             ->from('#__extensions AS a')
  344.             ->where('a.type = ' . $db->quote('language'))
  345.             ->where('state = 0')
  346.             ->where('enabled = 1')
  347.             ->where('client_id=' . (int) $client_id);
  348.  
  349.         $db->setQuery($query);
  350.  
  351.         $this->langlist = $db->loadColumn();
  352.  
  353.         return $this->langlist;
  354.     }
  355.  
  356.     /**
  357.      * Compare two languages in order to sort them.
  358.      *
  359.      * @param   object  $lang1  The first language
  360.      * @param   object  $lang2  The second language
  361.      *
  362.      * @return  integer 
  363.      *
  364.      * @since   3.1
  365.      */
  366.     protected function compareLanguages($lang1, $lang2)
  367.     {
  368.         return strcmp($lang1->name, $lang2->name);
  369.     }
  370.  
  371.     /**
  372.      * Get the languages folder path.
  373.      *
  374.      * @return  string  The path to the languages folders
  375.      *
  376.      * @since   3.1
  377.      */
  378.     protected function getPath()
  379.     {
  380.         if (is_null($this->path))
  381.         {
  382.             $client     = $this->getClient();
  383.             $this->path = JLanguage::getLanguagePath($client->path);
  384.         }
  385.  
  386.         return $this->path;
  387.     }
  388.  
  389.     /**
  390.      * Get the client object of Administrator or Frontend.
  391.      *
  392.      * @param   string  $client  Name of the client object
  393.      *
  394.      * @return  object 
  395.      *
  396.      * @since   3.1
  397.      */
  398.     protected function getClient($client = 'administrator')
  399.     {
  400.         $this->client = JApplicationHelper::getClientInfo($client, true);
  401.  
  402.         return $this->client;
  403.     }
  404.  
  405.     /**
  406.      * Set the default language.
  407.      *
  408.      * @param   string  $language    The language to be set as default
  409.      * @param   string  $cms_client  The name of the CMS client
  410.      *
  411.      * @return  boolean 
  412.      *
  413.      * @since   3.1
  414.      */
  415.     public function setDefault($language, $cms_client = 'administrator')
  416.     {
  417.         // Get the application
  418.         /* @var InstallationApplicationWeb $app */
  419.         $app = JFactory::getApplication();
  420.  
  421.         $client = $this->getClient($cms_client);
  422.  
  423.         $params = JComponentHelper::getParams('com_languages');
  424.         $params->set($client->name, $language);
  425.  
  426.         $table = JTable::getInstance('extension');
  427.         $id    = $table->find(array('element' => 'com_languages'));
  428.  
  429.         // Load
  430.         if (!$table->load($id))
  431.         {
  432.             $app->enqueueMessage($table->getError(), 'warning');
  433.  
  434.             return false;
  435.         }
  436.  
  437.         $table->params = (string) $params;
  438.  
  439.         // Pre-save checks
  440.         if (!$table->check())
  441.         {
  442.             $app->enqueueMessage($table->getError(), 'warning');
  443.  
  444.             return false;
  445.         }
  446.  
  447.         // Save the changes
  448.         if (!$table->store())
  449.         {
  450.             $app->enqueueMessage($table->getError(), 'warning');
  451.  
  452.             return false;
  453.         }
  454.  
  455.         return true;
  456.     }
  457.  
  458.     /**
  459.      * Get the current setup options from the session.
  460.      *
  461.      * @return  array 
  462.      *
  463.      * @since   3.1
  464.      */
  465.     public function getOptions()
  466.     {
  467.         $session = JFactory::getSession();
  468.         $options = $session->get('setup.options', array());
  469.  
  470.         return $options;
  471.     }
  472.  
  473.     /**
  474.      * Get the model form.
  475.      *
  476.      * @param   string  $view  The view being processed
  477.      *
  478.      * @return  mixed  JForm object on success, false on failure.
  479.      *
  480.      * @since   3.1
  481.      */
  482.     public function getForm($view = null)
  483.     {
  484.         /* @var InstallationApplicationWeb $app */
  485.         $app = JFactory::getApplication();
  486.  
  487.         if (!$view)
  488.         {
  489.             $view = $app->input->getWord('view', 'defaultlanguage');
  490.         }
  491.  
  492.         // Get the form.
  493.         JForm::addFormPath(JPATH_COMPONENT . '/model/forms');
  494.         JForm::addFieldPath(JPATH_COMPONENT . '/model/fields');
  495.         JForm::addRulePath(JPATH_COMPONENT . '/model/rules');
  496.  
  497.         try
  498.         {
  499.             $form = JForm::getInstance('jform', $view, array('control' => 'jform'));
  500.         }
  501.         catch (Exception $e)
  502.         {
  503.             $app->enqueueMessage($e->getMessage(), 'error');
  504.  
  505.             return false;
  506.         }
  507.  
  508.         // Check the session for previously entered form data.
  509.         $data = (array) $this->getOptions();
  510.  
  511.         // Bind the form data if present.
  512.         if (!empty($data))
  513.         {
  514.             $form->bind($data);
  515.         }
  516.  
  517.         return $form;
  518.     }
  519.  
  520.     /**
  521.      * Enable a Joomla plugin
  522.      *
  523.      * @param   string  $pluginName  The name of plugin
  524.      *
  525.      * @return  boolean 
  526.      *
  527.      * @since   3.2
  528.      */
  529.     public function enablePlugin($pluginName)
  530.     {
  531.         // Create a new db object.
  532.         $db    = JFactory::getDbo();
  533.         $query = $db->getQuery(true);
  534.  
  535.         $query
  536.             ->clear()
  537.             ->update('#__extensions')
  538.             ->set('enabled = 1')
  539.             ->where('name = ' . $db->quote($pluginName))
  540.             ->where('type = ' . $db->quote('plugin'));
  541.  
  542.         $db->setQuery($query);
  543.  
  544.         if (!$db->execute())
  545.         {
  546.             return false;
  547.         }
  548.  
  549.         // Store language filter plugin parameters
  550.         if ($pluginName == 'plg_system_languagefilter')
  551.         {
  552.             $params = '{"detect_browser":"0","automatic_change":"1","item_associations":"1","remove_default_prefix":"0","lang_cookie":"0","alternate_meta":"1"}';
  553.             $query
  554.                 ->clear()
  555.                 ->update('#__extensions')
  556.                 ->set('params = ' . $db->quote($params))
  557.                 ->where('name = ' . $db->quote('plg_system_languagefilter'))
  558.                 ->where('type = ' . $db->quote('plugin'));
  559.  
  560.             $db->setQuery($query);
  561.  
  562.             if (!$db->execute())
  563.             {
  564.                 return false;
  565.             }
  566.         }
  567.  
  568.         return true;
  569.     }
  570.  
  571.     /**
  572.      * Enable the Language Switcher Module.
  573.      *
  574.      * @return  boolean 
  575.      *
  576.      * @since   3.2
  577.      */
  578.     public function addModuleLanguageSwitcher()
  579.     {
  580.         JTable::addIncludePath(JPATH_LIBRARIES . '/legacy/table/');
  581.         $tableModule = JTable::getInstance('Module', 'JTable');
  582.         $moduleData  = array(
  583.             'id'        => 0,
  584.             'title'     => 'Language Switcher',
  585.             'note'      => '',
  586.             'content'   => '',
  587.             'position'  => 'position-0',
  588.             'module'    => 'mod_languages',
  589.             'access'    => 1,
  590.             'showtitle' => 0,
  591.             'params'    =>
  592.                 '{"header_text":"","footer_text":"","dropdown":"0","image":"1","inline":"1","show_active":"1",'
  593.                 . '"full_name":"1","layout":"_:default","moduleclass_sfx":"","cache":"0","cache_time":"900","cachemode":"itemid",'
  594.                 . '"module_tag":"div","bootstrap_size":"0","header_tag":"h3","header_class":"","style":"0"}',
  595.             'client_id' => 0,
  596.             'language'  => '*',
  597.             'published' => 1
  598.         );
  599.  
  600.         // Bind the data.
  601.         if (!$tableModule->bind($moduleData))
  602.         {
  603.             return false;
  604.         }
  605.  
  606.         // Check the data.
  607.         if (!$tableModule->check())
  608.         {
  609.             return false;
  610.         }
  611.  
  612.         // Store the data.
  613.         if (!$tableModule->store())
  614.         {
  615.             return false;
  616.         }
  617.  
  618.         return $this->addModuleInModuleMenu((int) $tableModule->id);
  619.     }
  620.  
  621.     /**
  622.      * Add a Module in Module menus
  623.      *
  624.      * @param   integer  $moduleId  The Id of module
  625.      *
  626.      * @return  boolean 
  627.      *
  628.      * @since   3.2
  629.      */
  630.     public function addModuleInModuleMenu($moduleId)
  631.     {
  632.         // Create a new db object.
  633.         $db    = JFactory::getDbo();
  634.         $query = $db->getQuery(true);
  635.  
  636.         // Add Module in Module menus
  637.         $query->clear()
  638.             ->insert('#__modules_menu')
  639.             ->columns(array($db->quoteName('moduleid'), $db->quoteName('menuid')))
  640.             ->values($moduleId . ', 0');
  641.         $db->setQuery($query);
  642.  
  643.         try
  644.         {
  645.             $db->execute();
  646.         }
  647.         catch (RuntimeException $e)
  648.         {
  649.             return false;
  650.         }
  651.  
  652.         return true;
  653.     }
  654.  
  655.     /**
  656.      * Gets a unique language SEF string
  657.      *
  658.      * This function checks other existing language with the same code, if they exist provides a unique SEF name.
  659.      * For instance: en-GB, en-US and en-AU will share the same SEF code by default: www.mywebsite.com/en/
  660.      * To avoid this conflict, this function creates an specific SEF in case of existing conflict:
  661.      * For example: www.mywebsite.com/en-au/
  662.      *
  663.      * @param   stdClass    $itemLanguage   Language Object
  664.      * @param   stdClass[]  $siteLanguages  All Language Objects
  665.      *
  666.      * @return  string 
  667.      *
  668.      * @since   3.2
  669.      */
  670.     public function getSefString($itemLanguage, $siteLanguages)
  671.     {
  672.         $langs = explode('-', $itemLanguage->language);
  673.         $prefixToFind = $langs[0];
  674.  
  675.         $numberPrefixesFound = 0;
  676.         foreach ($siteLanguages as $siteLang)
  677.         {
  678.             $langs = explode('-', $siteLang->language);
  679.             $lang  = $langs[0];
  680.  
  681.             if ($lang == $prefixToFind)
  682.             {
  683.                 ++$numberPrefixesFound;
  684.             }
  685.         }
  686.  
  687.         if ($numberPrefixesFound == 1)
  688.         {
  689.             return $prefixToFind;
  690.         }
  691.         return strtolower($itemLanguage->language);
  692.     }
  693.  
  694.     /**
  695.      * Add a Content Language
  696.      *
  697.      * @param   stdClass  $itemLanguage   Language Object
  698.      * @param   string    $sefLangString  String to use for SEF so it doesn't conflict
  699.      *
  700.      * @return  boolean 
  701.      *
  702.      * @since   3.2
  703.      */
  704.     public function addLanguage($itemLanguage, $sefLangString)
  705.     {
  706.         $tableLanguage = JTable::getInstance('Language');
  707.  
  708.         $flag = strtolower(str_replace('-', '_',  $itemLanguage->language));
  709.  
  710.         // Load the native language name
  711.         $installationLocalisedIni = new JLanguage($itemLanguage->language, false);
  712.         $nativeLanguageName       = $installationLocalisedIni->_('INSTL_DEFAULTLANGUAGE_NATIVE_LANGUAGE_NAME');
  713.  
  714.         // If the local name do not exist in the translation file we use the international standard name
  715.         if ($nativeLanguageName == 'INSTL_DEFAULTLANGUAGE_NATIVE_LANGUAGE_NAME')
  716.         {
  717.             $nativeLanguageName = $itemLanguage->name;
  718.         }
  719.  
  720.         $langData = array(
  721.             'lang_id'      => 0,
  722.             'lang_code'    => $itemLanguage->language,
  723.             'title'        => $itemLanguage->name,
  724.             'title_native' => $nativeLanguageName,
  725.             'sef'          => $sefLangString,
  726.             'image'        => $flag,
  727.             'published'    => 1
  728.         );
  729.  
  730.         // Bind the data.
  731.         if (!$tableLanguage->bind($langData))
  732.         {
  733.             return false;
  734.         }
  735.  
  736.         // Check the data.
  737.         if (!$tableLanguage->check())
  738.         {
  739.             return false;
  740.         }
  741.  
  742.         // Store the data.
  743.         if (!$tableLanguage->store())
  744.         {
  745.             return false;
  746.         }
  747.  
  748.         return true;
  749.     }
  750.  
  751.     /**
  752.      * Add Menu Group
  753.      *
  754.      * @param   stdClass  $itemLanguage  Language Object
  755.      *
  756.      * @return  boolean 
  757.      *
  758.      * @since   3.2
  759.      */
  760.     public function addMenuGroup($itemLanguage)
  761.     {
  762.         // Add menus
  763.         JLoader::registerPrefix('J', JPATH_PLATFORM . '/legacy');
  764.         JTable::addIncludePath(JPATH_ADMINISTRATOR . '/components/com_menus/tables/');
  765.  
  766.         // Add Menu Group
  767.         $tableMenu = JTable::getInstance('Type', 'JTableMenu');
  768.  
  769.         $menuData = array(
  770.             'id'          => 0,
  771.             'menutype'    => 'mainmenu-' . strtolower($itemLanguage->language),
  772.             'title'       => 'Main Menu (' . $itemLanguage->language . ')',
  773.             'description' => 'The main menu for the site in language ' . $itemLanguage->name
  774.         );
  775.  
  776.         // Bind the data.
  777.         if (!$tableMenu->bind($menuData))
  778.         {
  779.             return false;
  780.         }
  781.  
  782.         // Check the data.
  783.         if (!$tableMenu->check())
  784.         {
  785.             return false;
  786.         }
  787.  
  788.         // Store the data.
  789.         if (!$tableMenu->store())
  790.         {
  791.             return false;
  792.         }
  793.  
  794.         return true;
  795.     }
  796.  
  797.     /**
  798.      * Add Menu Item.
  799.      *
  800.      * @param   stdClass  $itemLanguage  Language Object
  801.      *
  802.      * @return  boolean 
  803.      *
  804.      * @since   3.2
  805.      */
  806.     public function addMenuItem($itemLanguage)
  807.     {
  808.         // Add Menu Item
  809.         $tableItem = JTable::getInstance('Menu', 'MenusTable');
  810.  
  811.         $newlanguage = new JLanguage($itemLanguage->language, false);
  812.         $newlanguage->load('com_languages', JPATH_ADMINISTRATOR, $itemLanguage->language, true);
  813.         $title = $newlanguage->_('COM_LANGUAGES_HOMEPAGE');
  814.         $alias = 'home_' . $itemLanguage->language;
  815.  
  816.         $menuItem = array(
  817.             'id'           => 0,
  818.             'title'        => $title,
  819.             'alias'        => $alias,
  820.             'menutype'     => 'mainmenu-' . strtolower($itemLanguage->language),
  821.             'type'         => 'component',
  822.             'link'         => 'index.php?option=com_content&view=featured',
  823.             'component_id' => 22,
  824.             'published'    => 1,
  825.             'parent_id'    => 1,
  826.             'level'        => 1,
  827.             'home'         => 1,
  828.             'params'       => '{"featured_categories":[""],"layout_type":"blog","num_leading_articles":"1",'
  829.                 . '"num_intro_articles":"3","num_columns":"3","num_links":"0","orderby_pri":"","orderby_sec":"front",'
  830.                 . '"order_date":"","multi_column_order":"1","show_pagination":"2","show_pagination_results":"1","show_noauth":"",'
  831.                 . '"article-allow_ratings":"","article-allow_comments":"","show_feed_link":"1","feed_summary":"",'
  832.                 . '"show_title":"","link_titles":"","show_intro":"","show_category":"","link_category":"",'
  833.                 . '"show_parent_category":"","link_parent_category":"","show_author":"","show_create_date":"",'
  834.                 . '"show_modify_date":"","show_publish_date":"","show_item_navigation":"","show_readmore":"",'
  835.                 . '"show_icons":"","show_print_icon":"","show_email_icon":"","show_hits":"","menu-anchor_title":"",'
  836.                 . '"menu-anchor_css":"","menu_image":"","show_page_heading":1,"page_title":"","page_heading":"",'
  837.                 . '"pageclass_sfx":"","menu-meta_description":"","menu-meta_keywords":"","robots":"","secure":0}',
  838.             'language'     => $itemLanguage->language
  839.         );
  840.  
  841.         // Bind the data.
  842.         if (!$tableItem->bind($menuItem))
  843.         {
  844.             return false;
  845.         }
  846.  
  847.         $tableItem->setLocation($menuItem['parent_id'], 'last-child');
  848.  
  849.         // Check the data.
  850.         if (!$tableItem->check())
  851.         {
  852.             return false;
  853.         }
  854.  
  855.         // Store the data.
  856.         if (!$tableItem->store())
  857.         {
  858.             return false;
  859.         }
  860.  
  861.         // Rebuild the tree path.
  862.         if (!$tableItem->rebuildPath($tableItem->id))
  863.         {
  864.             return false;
  865.         }
  866.  
  867.         return true;
  868.     }
  869.  
  870.     /**
  871.      * Add Module Menu
  872.      *
  873.      * @param   stdClass  $itemLanguage  Language Object
  874.      *
  875.      * @return  boolean 
  876.      *
  877.      * @since   3.2
  878.      */
  879.     public function addModuleMenu($itemLanguage)
  880.     {
  881.         $tableModule = JTable::getInstance('Module', 'JTable');
  882.         $title = 'Main menu ' . $itemLanguage->language;
  883.  
  884.         $moduleData = array(
  885.             'id'        => 0,
  886.             'title'     => $title,
  887.             'note'      => '',
  888.             'content'   => '',
  889.             'position'  => 'position-7',
  890.             'module'    => 'mod_menu',
  891.             'access'    => 1,
  892.             'showtitle' => 1,
  893.             'params'    => '{"menutype":"mainmenu-' . strtolower($itemLanguage->language)
  894.                 . '","startLevel":"0","endLevel":"0","showAllChildren":"0","tag_id":"","class_sfx":"","window_open":"",'
  895.                 . '"layout":"","moduleclass_sfx":"_menu","cache":"1","cache_time":"900","cachemode":"itemid"}',
  896.             'client_id' => 0,
  897.             'language'  => $itemLanguage->language,
  898.             'published' => 1
  899.         );
  900.  
  901.         // Bind the data.
  902.         if (!$tableModule->bind($moduleData))
  903.         {
  904.             return false;
  905.         }
  906.  
  907.         // Check the data.
  908.         if (!$tableModule->check())
  909.         {
  910.             return false;
  911.         }
  912.  
  913.         // Store the data.
  914.         if (!$tableModule->store())
  915.         {
  916.             return false;
  917.         }
  918.  
  919.         return $this->addModuleInModuleMenu((int) $tableModule->id);
  920.     }
  921.  
  922.     /**
  923.      * Disable Default Main Menu Module
  924.      *
  925.      * @return  boolean 
  926.      *
  927.      * @since   3.2
  928.      */
  929.     public function disableModuleMainMenu()
  930.     {
  931.         // Create a new db object.
  932.         $db    = JFactory::getDbo();
  933.         $query = $db->getQuery(true);
  934.  
  935.         // Add Module in Module menus
  936.         $query
  937.             ->clear()
  938.             ->update($db->quoteName('#__modules'))
  939.             ->set($db->quoteName('published') . ' = 0')
  940.             ->where($db->quoteName('module') . ' = ' . $db->quote('mod_menu'))
  941.             ->where($db->quoteName('language') . ' = ' . $db->quote('*'))
  942.             ->where($db->quoteName('client_id') . ' = ' . $db->quote('0'))
  943.             ->where($db->quoteName('position') . ' = ' . $db->quote('position-7'));
  944.         $db->setQuery($query);
  945.  
  946.         if (!$db->execute())
  947.         {
  948.             return false;
  949.         }
  950.  
  951.         return true;
  952.     }
  953.  
  954.     /**
  955.      * Enable a module
  956.      *
  957.      * @param   string  $moduleName  The Name of the module to activate
  958.      *
  959.      * @return  boolean 
  960.      *
  961.      * @since   3.2
  962.      */
  963.     public function enableModule($moduleName)
  964.     {
  965.         // Create a new db object.
  966.         $db    = JFactory::getDbo();
  967.         $query = $db->getQuery(true);
  968.  
  969.         $query
  970.             ->clear()
  971.             ->update($db->quoteName('#__modules'))
  972.             ->set($db->quoteName('published') . ' = 1')
  973.             ->where($db->quoteName('module') . ' = ' . $db->quote($moduleName));
  974.         $db->setQuery($query);
  975.  
  976.         if (!$db->execute())
  977.         {
  978.             return false;
  979.         }
  980.  
  981.         return true;
  982.     }
  983.  
  984.     /**
  985.      * Method create a category for a specific language
  986.      *
  987.      * @param   stdClass  $itemLanguage  Language Object
  988.      *
  989.      * @return  JTable Category Object
  990.      *
  991.      * @since   3.2
  992.      */
  993.     public function addCategory($itemLanguage)
  994.     {
  995.         $newlanguage = new JLanguage($itemLanguage->language, false);
  996.         $newlanguage->load('joomla', JPATH_ADMINISTRATOR, $itemLanguage->language, true);
  997.         $title = $newlanguage->_('JCATEGORY');
  998.  
  999.         // Initialize a new category
  1000.         $category                  = JTable::getInstance('Category');
  1001.         $category->extension       = 'com_content';
  1002.         $category->title           = $title . ' (' . strtolower($itemLanguage->language) . ')';
  1003.         $category->description     = '';
  1004.         $category->published       = 1;
  1005.         $category->access          = 1;
  1006.         $category->params          = '{"target":"","image":""}';
  1007.         $category->metadata        = '{"page_title":"","author":"","robots":""}';
  1008.         $category->created_time    = JFactory::getDate()->toSql();
  1009.         $category->language        = $itemLanguage->language;
  1010.  
  1011.         // Set the location in the tree
  1012.         $category->setLocation(1, 'last-child');
  1013.  
  1014.         // Check to make sure our data is valid
  1015.         if (!$category->check())
  1016.         {
  1017.             return false;
  1018.         }
  1019.  
  1020.         // Store the category
  1021.         if (!$category->store(true))
  1022.         {
  1023.             return false;
  1024.         }
  1025.  
  1026.         // Build the path for our category
  1027.         $category->rebuildPath($category->id);
  1028.  
  1029.         return $category;
  1030.     }
  1031.  
  1032.     /**
  1033.      * Create an article in a specific language
  1034.      *
  1035.      * @param   stdClass  $itemLanguage  Language Object
  1036.      * @param   int       $categoryId    The id of the category where we want to add the article
  1037.      *
  1038.      * @return  JTable Category Object
  1039.      *
  1040.      * @since   3.2
  1041.      */
  1042.     public function addArticle($itemLanguage, $categoryId)
  1043.     {
  1044.         $db = JFactory::getDbo();
  1045.  
  1046.         $newlanguage = new JLanguage($itemLanguage->language, false);
  1047.         $newlanguage->load('plg_editors-xtd_article', JPATH_ADMINISTRATOR, $itemLanguage->language, true);
  1048.         $title = $newlanguage->_('PLG_ARTICLE_BUTTON_ARTICLE');
  1049.  
  1050.         $article                   = JTable::getInstance('Content');
  1051.         $article->title            = $title . ' (' . strtolower($itemLanguage->language) . ')';
  1052.         $article->introtext        = '<p>Lorem ipsum ad his scripta blandit partiendo, eum fastidii accumsan euripidis'
  1053.                                         . ' in, eum liber hendrerit an. Qui ut wisi vocibus suscipiantur, quo dicit'
  1054.                                         . ' ridens inciderint id. Quo mundi lobortis reformidans eu, legimus senserit'
  1055.                                         . 'definiebas an eos. Eu sit tincidunt incorrupte definitionem, vis mutat'
  1056.                                         . ' affert percipit cu, eirmod consectetuer signiferumque eu per. In usu latine'
  1057.                                         . 'equidem dolores. Quo no falli viris intellegam, ut fugit veritus placerat'
  1058.                                         . 'per. Ius id vidit volumus mandamus, vide veritus democritum te nec, ei eos'
  1059.                                         . 'debet libris consulatu.</p>';
  1060.         $article->state            = 1;
  1061.         $article->created          = JFactory::getDate()->toSql();
  1062.         $article->created_by       = $this->getAdminId();
  1063.         $article->created_by_alias = 'Joomla';
  1064.         $article->publish_up       = JFactory::getDate()->toSql();
  1065.         $article->publish_down     = $db->getNullDate();
  1066.         $article->version          = 1;
  1067.         $article->catid            = $categoryId;
  1068.         $article->metadata         = '{"robots":"","author":"","rights":"","xreference":"","tags":null}';
  1069.         $article->language         = $itemLanguage->language;
  1070.         $article->featured         = 1;
  1071.  
  1072.         // Check to make sure our data is valid
  1073.         if (!$article->check())
  1074.         {
  1075.             return false;
  1076.         }
  1077.  
  1078.         // Now store the category
  1079.         if (!$article->store(true))
  1080.         {
  1081.             return false;
  1082.         }
  1083.  
  1084.         // Get the new item ID
  1085.         $newId = $article->get('id');
  1086.  
  1087.         $query = $db->getQuery(true)
  1088.             ->insert($db->quoteName('#__content_frontpage'))
  1089.             ->values($newId . ', 0');
  1090.  
  1091.         $db->setQuery($query);
  1092.  
  1093.         if (!$db->execute())
  1094.         {
  1095.             return false;
  1096.         }
  1097.  
  1098.         return true;
  1099.     }
  1100.  
  1101.     /**
  1102.      * Retrieve the admin user id.
  1103.      *
  1104.      * @return  int|boolOne Administrator ID
  1105.      *
  1106.      * @since   3.2
  1107.      */
  1108.     private function getAdminId()
  1109.     {
  1110.         if ($this->adminId)
  1111.         {
  1112.             // Return local cached admin ID
  1113.             return $this->adminId;
  1114.         }
  1115.  
  1116.         $db    = JFactory::getDbo();
  1117.         $query = $db->getQuery(true);
  1118.  
  1119.         // Select the required fields from the updates table
  1120.         $query
  1121.             ->clear()
  1122.             ->select('u.id')
  1123.             ->from('#__users as u')
  1124.             ->join('LEFT', '#__user_usergroup_map AS map ON map.user_id = u.id')
  1125.             ->join('LEFT', '#__usergroups AS g ON map.group_id = g.id')
  1126.             ->where('g.title = ' . $db->q('Super Users'));
  1127.  
  1128.         $db->setQuery($query);
  1129.         $id = $db->loadResult();
  1130.  
  1131.         if (!$id || $id instanceof Exception)
  1132.         {
  1133.             return false;
  1134.         }
  1135.  
  1136.         return $id;
  1137.     }
  1138. }

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