Source for file installed.php

Documentation is available at installed.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_languages
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. /**
  13.  * Languages Component Languages Model
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_languages
  17.  * @since       1.6
  18.  */
  19. class LanguagesModelInstalled extends JModelList
  20. {
  21.     /**
  22.      * @var object client object
  23.      */
  24.     protected $client = null;
  25.  
  26.     /**
  27.      * @var object user object
  28.      */
  29.     protected $user = null;
  30.  
  31.     /**
  32.      * @var boolean|JExeptionTrue, if FTP settings should be shown, or an exeption
  33.      */
  34.     protected $ftp = null;
  35.  
  36.     /**
  37.      * @var string option name
  38.      */
  39.     protected $option = null;
  40.  
  41.     /**
  42.      * @var array languages description
  43.      */
  44.     protected $data = null;
  45.  
  46.     /**
  47.      * @var int total number pf languages
  48.      */
  49.     protected $total = null;
  50.  
  51.     /**
  52.      * @var int total number pf languages installed
  53.      */
  54.     protected $langlist = null;
  55.  
  56.     /**
  57.      * @var string language path
  58.      */
  59.     protected $path = null;
  60.  
  61.     /**
  62.      * Method to auto-populate the model state.
  63.      *
  64.      * Note. Calling getState in this method will result in recursion.
  65.      *
  66.      * @return  void 
  67.      * @since   1.6
  68.      */
  69.     protected function populateState($ordering = null, $direction = null)
  70.     {
  71.         $app = JFactory::getApplication('administrator');
  72.  
  73.         // Load the filter state.
  74.         $clientId = $app->input->getInt('client');
  75.         $this->setState('filter.client_id', $clientId);
  76.  
  77.         // Load the parameters.
  78.         $params = JComponentHelper::getParams('com_languages');
  79.         $this->setState('params', $params);
  80.  
  81.         // List state information.
  82.         parent::populateState('a.name', 'asc');
  83.     }
  84.  
  85.     /**
  86.      * Method to get a store id based on model configuration state.
  87.      *
  88.      * This is necessary because the model is used by the component and
  89.      * different modules that might need different sets of data or different
  90.      * ordering requirements.
  91.      *
  92.      * @param   string  $id    A prefix for the store id.
  93.      *
  94.      * @return  string  A store id.
  95.      * @since   1.6
  96.      */
  97.     protected function getStoreId($id = '')
  98.     {
  99.         // Compile the store id.
  100.         $id    .= ':'.$this->getState('filter.client_id');
  101.  
  102.         return parent::getStoreId($id);
  103.     }
  104.  
  105.     /**
  106.      * Method to get the client object
  107.      *
  108.      * @return  object 
  109.      * @since   1.6
  110.      */
  111.     public function &getClient()
  112.     {
  113.         if (is_null($this->client))
  114.         {
  115.             $this->client = JApplicationHelper::getClientInfo($this->getState('filter.client_id', 0));
  116.         }
  117.  
  118.         return $this->client;
  119.     }
  120.  
  121.     /**
  122.      * Method to get the ftp credentials
  123.      *
  124.      * @return  object 
  125.      * @since   1.6
  126.      */
  127.     public function &getFtp()
  128.     {
  129.         if (is_null($this->ftp))
  130.         {
  131.             $this->ftp = JClientHelper::setCredentialsFromRequest('ftp');
  132.         }
  133.  
  134.         return $this->ftp;
  135.     }
  136.  
  137.     /**
  138.      * Method to get the option
  139.      *
  140.      * @return  object 
  141.      * @since   1.6
  142.      */
  143.     public function &getOption()
  144.     {
  145.         $option = $this->getState('option');
  146.  
  147.         return $option;
  148.     }
  149.  
  150.     /**
  151.      * Method to get Languages item data
  152.      *
  153.      * @return  array 
  154.      * @since   1.6
  155.      */
  156.     public function &getData()
  157.     {
  158.         if (is_null($this->data)) {
  159.  
  160.             // Get information
  161.             $path        = $this->getPath();
  162.             $client        = $this->getClient();
  163.             $langlist   = $this->getLanguageList();
  164.  
  165.             // Compute all the languages
  166.             $data    = array ();
  167.  
  168.             foreach ($langlist as $lang) {
  169.                 $file = $path . '/' . $lang . '/' . $lang.'.xml';
  170.                 $info = JApplicationHelper::parseXMLLangMetaFile($file);
  171.                 $row = new JObject;
  172.                 $row->language = $lang;
  173.  
  174.                 if (!is_array($info))
  175.                 {
  176.                     continue;
  177.                 }
  178.  
  179.                 foreach ($info as $key => $value)
  180.                 {
  181.                     $row->$key = $value;
  182.                 }
  183.  
  184.                 // if current than set published
  185.                 $params = JComponentHelper::getParams('com_languages');
  186.                 if ($params->get($client->name, 'en-GB') == $row->language)
  187.                 {
  188.                     $row->published    = 1;
  189.                 }
  190.                 else {
  191.                     $row->published = 0;
  192.                 }
  193.  
  194.                 $row->checked_out = 0;
  195.                 $data[] = $row;
  196.             }
  197.             usort($data, array($this, 'compareLanguages'));
  198.  
  199.             // Prepare data
  200.             $limit = $this->getState('list.limit');
  201.             $start = $this->getState('list.start');
  202.             $total = $this->getTotal();
  203.  
  204.             if ($limit == 0)
  205.             {
  206.                 $start = 0;
  207.                 $end = $total;
  208.             }
  209.             else {
  210.                 if ($start > $total)
  211.                 {
  212.                     $start = $total - $total % $limit;
  213.                 }
  214.                 $end = $start + $limit;
  215.  
  216.                 if ($end > $total)
  217.                 {
  218.                     $end = $total;
  219.                 }
  220.             }
  221.  
  222.             // Compute the displayed languages
  223.             $this->data    = array();
  224.             for ($i = $start;$i < $end;$i++)
  225.             {
  226.                 $this->data[] = & $data[$i];
  227.             }
  228.         }
  229.  
  230.         return $this->data;
  231.     }
  232.  
  233.     /**
  234.      * Method to get installed languages data.
  235.      *
  236.      * @return  string    An SQL query
  237.      * @since   1.6
  238.      */
  239.     protected function getLanguageList()
  240.     {
  241.         // Create a new db object.
  242.         $db = $this->getDbo();
  243.         $query = $db->getQuery(true);
  244.         $client = $this->getState('filter.client_id');
  245.         $type = "language";
  246.         // Select field element from the extensions table.
  247.         $query->select($this->getState('list.select', 'a.element'))
  248.             ->from('#__extensions AS a');
  249.  
  250.         $type = $db->quote($type);
  251.         $query->where('(a.type = '.$type.')')
  252.  
  253.             ->where('state = 0')
  254.             ->where('enabled = 1')
  255.  
  256.             ->where('client_id=' . (int) $client);
  257.  
  258.         // for client_id = 1 do we need to check language table also ?
  259.         $db->setQuery($query);
  260.  
  261.         $this->langlist = $db->loadColumn();
  262.  
  263.         return $this->langlist;
  264.     }
  265.  
  266.     /**
  267.      * Method to get the total number of Languages items
  268.      *
  269.      * @return  integer 
  270.      * @since   1.6
  271.      */
  272.     public function getTotal()
  273.     {
  274.         if (is_null($this->total))
  275.         {
  276.             $langlist = $this->getLanguageList();
  277.             $this->total = count($langlist);
  278.         }
  279.  
  280.         return $this->total;
  281.     }
  282.  
  283.     /**
  284.      * Method to set the default language
  285.      *
  286.      * @return  boolean 
  287.      * @since   1.6
  288.      */
  289.     public function publish($cid)
  290.     {
  291.         if ($cid)
  292.         {
  293.             $client    = $this->getClient();
  294.  
  295.             $params = JComponentHelper::getParams('com_languages');
  296.             $params->set($client->name, $cid);
  297.  
  298.             $table = JTable::getInstance('extension');
  299.             $id = $table->find(array('element' => 'com_languages'));
  300.  
  301.             // Load
  302.             if (!$table->load($id))
  303.             {
  304.                 $this->setError($table->getError());
  305.                 return false;
  306.             }
  307.  
  308.             $table->params = (string) $params;
  309.             // pre-save checks
  310.             if (!$table->check())
  311.             {
  312.                 $this->setError($table->getError());
  313.                 return false;
  314.             }
  315.  
  316.             // save the changes
  317.             if (!$table->store())
  318.             {
  319.                 $this->setError($table->getError());
  320.                 return false;
  321.             }
  322.         }
  323.         else
  324.         {
  325.             $this->setError(JText::_('COM_LANGUAGES_ERR_NO_LANGUAGE_SELECTED'));
  326.             return false;
  327.         }
  328.  
  329.         // Clean the cache of com_languages and component cache.
  330.         $this->cleanCache();
  331.         $this->cleanCache('_system');
  332.  
  333.         return true;
  334.     }
  335.  
  336.     /**
  337.      * Method to get the folders
  338.      *
  339.      * @return  array  Languages folders
  340.      * @since   1.6
  341.      */
  342.     protected function getFolders()
  343.     {
  344.         if (is_null($this->folders))
  345.         {
  346.             $path = $this->getPath();
  347.             jimport('joomla.filesystem.folder');
  348.             $this->folders = JFolder::folders($path, '.', false, false, array('.svn', 'CVS', '.DS_Store', '__MACOSX', 'pdf_fonts', 'overrides'));
  349.         }
  350.  
  351.         return $this->folders;
  352.     }
  353.  
  354.     /**
  355.      * Method to get the path
  356.      *
  357.      * @return  string    The path to the languages folders
  358.      * @since   1.6
  359.      */
  360.     protected function getPath()
  361.     {
  362.         if (is_null($this->path))
  363.         {
  364.             $client = $this->getClient();
  365.             $this->path = JLanguage::getLanguagePath($client->path);
  366.         }
  367.  
  368.         return $this->path;
  369.     }
  370.  
  371.     /**
  372.      * Method to compare two languages in order to sort them
  373.      *
  374.      * @param   object    $lang1 the first language
  375.      * @param   object    $lang2 the second language
  376.      *
  377.      * @return  integer 
  378.      * @since   1.6
  379.      */
  380.     protected function compareLanguages($lang1, $lang2)
  381.     {
  382.         return strcmp($lang1->name, $lang2->name);
  383.     }
  384. }

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