1 <?php
  2 /**
  3  * @package     Joomla.Platform
  4  * @subpackage  Language
  5  *
  6  * @copyright   Copyright (C) 2005 - 2017 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 use Joomla\Utilities\ArrayHelper;
 13 
 14 /**
 15  * Language helper class
 16  *
 17  * @since  11.1
 18  */
 19 class JLanguageHelper
 20 {
 21     /**
 22      * Builds a list of the system languages which can be used in a select option
 23      *
 24      * @param   string   $actualLanguage  Client key for the area
 25      * @param   string   $basePath        Base path to use
 26      * @param   boolean  $caching         True if caching is used
 27      * @param   boolean  $installed       Get only installed languages
 28      *
 29      * @return  array  List of system languages
 30      *
 31      * @since   11.1
 32      */
 33     public static function createLanguageList($actualLanguage, $basePath = JPATH_BASE, $caching = false, $installed = false)
 34     {
 35         $list      = array();
 36         $clientId  = $basePath === JPATH_ADMINISTRATOR ? 1 : 0;
 37         $languages = $installed ? static::getInstalledLanguages($clientId, true) : self::getKnownLanguages($basePath);
 38 
 39         foreach ($languages as $languageCode => $language)
 40         {
 41             $metadata = $installed ? $language->metadata : $language;
 42 
 43             $list[] = array(
 44                 'text'     => isset($metadata['nativeName']) ? $metadata['nativeName'] : $metadata['name'],
 45                 'value'    => $languageCode,
 46                 'selected' => $languageCode === $actualLanguage ? 'selected="selected"' : null,
 47             );
 48         }
 49 
 50         return $list;
 51     }
 52 
 53     /**
 54      * Tries to detect the language.
 55      *
 56      * @return  string  locale or null if not found
 57      *
 58      * @since   11.1
 59      */
 60     public static function detectLanguage()
 61     {
 62         if (isset($_SERVER['HTTP_ACCEPT_LANGUAGE']))
 63         {
 64             $browserLangs = explode(',', $_SERVER['HTTP_ACCEPT_LANGUAGE']);
 65             $systemLangs = self::getLanguages();
 66 
 67             foreach ($browserLangs as $browserLang)
 68             {
 69                 // Slice out the part before ; on first step, the part before - on second, place into array
 70                 $browserLang = substr($browserLang, 0, strcspn($browserLang, ';'));
 71                 $primary_browserLang = substr($browserLang, 0, 2);
 72 
 73                 foreach ($systemLangs as $systemLang)
 74                 {
 75                     // Take off 3 letters iso code languages as they can't match browsers' languages and default them to en
 76                     $Jinstall_lang = $systemLang->lang_code;
 77 
 78                     if (strlen($Jinstall_lang) < 6)
 79                     {
 80                         if (strtolower($browserLang) == strtolower(substr($systemLang->lang_code, 0, strlen($browserLang))))
 81                         {
 82                             return $systemLang->lang_code;
 83                         }
 84                         elseif ($primary_browserLang == substr($systemLang->lang_code, 0, 2))
 85                         {
 86                             $primaryDetectedLang = $systemLang->lang_code;
 87                         }
 88                     }
 89                 }
 90 
 91                 if (isset($primaryDetectedLang))
 92                 {
 93                     return $primaryDetectedLang;
 94                 }
 95             }
 96         }
 97 
 98         return;
 99     }
100 
101     /**
102      * Get available languages
103      *
104      * @param   string  $key  Array key
105      *
106      * @return  array  An array of published languages
107      *
108      * @since   11.1
109      */
110     public static function getLanguages($key = 'default')
111     {
112         static $languages;
113 
114         if (empty($languages))
115         {
116             // Installation uses available languages
117             if (JFactory::getApplication()->getClientId() == 2)
118             {
119                 $languages[$key] = array();
120                 $knownLangs = self::getKnownLanguages(JPATH_BASE);
121 
122                 foreach ($knownLangs as $metadata)
123                 {
124                     // Take off 3 letters iso code languages as they can't match browsers' languages and default them to en
125                     $obj = new stdClass;
126                     $obj->lang_code = $metadata['tag'];
127                     $languages[$key][] = $obj;
128                 }
129             }
130             else
131             {
132                 $cache = JFactory::getCache('com_languages', '');
133 
134                 if ($cache->contains('languages'))
135                 {
136                     $languages = $cache->get('languages');
137                 }
138                 else
139                 {
140                     $db = JFactory::getDbo();
141                     $query = $db->getQuery(true)
142                         ->select('*')
143                         ->from('#__languages')
144                         ->where('published=1')
145                         ->order('ordering ASC');
146                     $db->setQuery($query);
147 
148                     $languages['default'] = $db->loadObjectList();
149                     $languages['sef'] = array();
150                     $languages['lang_code'] = array();
151 
152                     if (isset($languages['default'][0]))
153                     {
154                         foreach ($languages['default'] as $lang)
155                         {
156                             $languages['sef'][$lang->sef] = $lang;
157                             $languages['lang_code'][$lang->lang_code] = $lang;
158                         }
159                     }
160 
161                     $cache->store($languages, 'languages');
162                 }
163             }
164         }
165 
166         return $languages[$key];
167     }
168 
169     /**
170      * Get a list of installed languages.
171      *
172      * @param   integer  $clientId         The client app id.
173      * @param   boolean  $processMetaData  Fetch Language metadata.
174      * @param   boolean  $processManifest  Fetch Language manifest.
175      * @param   string   $pivot            The pivot of the returning array.
176      * @param   string   $orderField       Field to order the results.
177      * @param   string   $orderDirection   Direction to order the results.
178      *
179      * @return  array  Array with the installed languages.
180      *
181      * @since   3.7.0
182      */
183     public static function getInstalledLanguages($clientId = null, $processMetaData = false, $processManifest = false, $pivot = 'element',
184         $orderField = null, $orderDirection = null)
185     {
186         static $installedLanguages = null;
187 
188         if ($installedLanguages === null)
189         {
190             $cache = JFactory::getCache('com_languages', '');
191 
192             if ($cache->contains('installedlanguages'))
193             {
194                 $installedLanguages = $cache->get('installedlanguages');
195             }
196             else
197             {
198                 $db = JFactory::getDbo();
199 
200                 $query = $db->getQuery(true)
201                     ->select($db->quoteName(array('element', 'name', 'client_id', 'extension_id')))
202                     ->from($db->quoteName('#__extensions'))
203                     ->where($db->quoteName('type') . ' = ' . $db->quote('language'))
204                     ->where($db->quoteName('state') . ' = 0')
205                     ->where($db->quoteName('enabled') . ' = 1');
206 
207                 $installedLanguages = $db->setQuery($query)->loadObjectList();
208 
209                 $cache->store($installedLanguages, 'installedlanguages');
210             }
211         }
212 
213         $clients   = $clientId === null ? array(0, 1) : array((int) $clientId);
214         $languages = array(
215             0 => array(),
216             1 => array(),
217         );
218 
219         foreach ($installedLanguages as $language)
220         {
221             // If the language client is not needed continue cycle. Drop for performance.
222             if (!in_array((int) $language->client_id, $clients))
223             {
224                 continue;
225             }
226 
227             $lang = $language;
228 
229             if ($processMetaData || $processManifest)
230             {
231                 $clientPath = (int) $language->client_id === 0 ? JPATH_SITE : JPATH_ADMINISTRATOR;
232                 $metafile   = self::getLanguagePath($clientPath, $language->element) . '/' . $language->element . '.xml';
233 
234                 // Process the language metadata.
235                 if ($processMetaData)
236                 {
237                     try
238                     {
239                         $lang->metadata = self::parseXMLLanguageFile($metafile);
240                     }
241                     // Not able to process xml language file. Fail silently.
242                     catch (Exception $e)
243                     {
244                         JLog::add(JText::sprintf('JLIB_LANGUAGE_ERROR_CANNOT_LOAD_METAFILE', $language->element, $metafile), JLog::WARNING, 'language');
245 
246                         continue;
247                     }
248 
249                     // No metadata found, not a valid language. Fail silently.
250                     if (!is_array($lang->metadata))
251                     {
252                         JLog::add(JText::sprintf('JLIB_LANGUAGE_ERROR_CANNOT_LOAD_METADATA', $language->element, $metafile), JLog::WARNING, 'language');
253 
254                         continue;
255                     }
256                 }
257 
258                 // Process the language manifest.
259                 if ($processManifest)
260                 {
261                     try
262                     {
263                         $lang->manifest = JInstaller::parseXMLInstallFile($metafile);
264                     }
265                     // Not able to process xml language file. Fail silently.
266                     catch (Exception $e)
267                     {
268                         JLog::add(JText::sprintf('JLIB_LANGUAGE_ERROR_CANNOT_LOAD_METAFILE', $language->element, $metafile), JLog::WARNING, 'language');
269 
270                         continue;
271                     }
272 
273                     // No metadata found, not a valid language. Fail silently.
274                     if (!is_array($lang->manifest))
275                     {
276                         JLog::add(JText::sprintf('JLIB_LANGUAGE_ERROR_CANNOT_LOAD_METADATA', $language->element, $metafile), JLog::WARNING, 'language');
277 
278                         continue;
279                     }
280                 }
281             }
282 
283             $languages[$language->client_id][] = $lang;
284         }
285 
286         // Order the list, if needed.
287         if ($orderField !== null && $orderDirection !== null)
288         {
289             $orderDirection = strtolower($orderDirection) === 'desc' ? -1 : 1;
290 
291             foreach ($languages as $cId => $language)
292             {
293                 // If the language client is not needed continue cycle. Drop for performance.
294                 if (!in_array($cId, $clients))
295                 {
296                     continue;
297                 }
298 
299                 $languages[$cId] = ArrayHelper::sortObjects($languages[$cId], $orderField, $orderDirection, true, true);
300             }
301         }
302 
303         // Add the pivot, if needed.
304         if ($pivot !== null)
305         {
306             foreach ($languages as $cId => $language)
307             {
308                 // If the language client is not needed continue cycle. Drop for performance.
309                 if (!in_array($cId, $clients))
310                 {
311                     continue;
312                 }
313 
314                 $languages[$cId] = ArrayHelper::pivot($languages[$cId], $pivot);
315             }
316         }
317 
318         return $clientId !== null ? $languages[$clientId] : $languages;
319     }
320 
321     /**
322      * Get a list of content languages.
323      *
324      * @param   boolean  $checkPublished  Check if the content language is published.
325      * @param   boolean  $checkInstalled  Check if the content language is installed.
326      * @param   string   $pivot           The pivot of the returning array.
327      * @param   string   $orderField      Field to order the results.
328      * @param   string   $orderDirection  Direction to order the results.
329      *
330      * @return  array  Array of the content languages.
331      *
332      * @since   3.7.0
333      */
334     public static function getContentLanguages($checkPublished = true, $checkInstalled = true, $pivot = 'lang_code', $orderField = null,
335         $orderDirection = null)
336     {
337         static $contentLanguages = null;
338 
339         if ($contentLanguages === null)
340         {
341             $cache = JFactory::getCache('com_languages', '');
342 
343             if ($cache->contains('contentlanguages'))
344             {
345                 $contentLanguages = $cache->get('contentlanguages');
346             }
347             else
348             {
349                 $db = JFactory::getDbo();
350 
351                 $query = $db->getQuery(true)
352                     ->select('*')
353                     ->from($db->quoteName('#__languages'));
354 
355                 $contentLanguages = $db->setQuery($query)->loadObjectList();
356 
357                 $cache->store($contentLanguages, 'contentlanguages');
358             }
359         }
360 
361         $languages = $contentLanguages;
362 
363         // Check if the language is published, if needed.
364         if ($checkPublished)
365         {
366             foreach ($languages as $key => $language)
367             {
368                 if ((int) $language->published === 0)
369                 {
370                     unset($languages[$key]);
371                 }
372             }
373         }
374 
375         // Check if the language is installed, if needed.
376         if ($checkInstalled)
377         {
378             $languages = array_values(array_intersect_key(ArrayHelper::pivot($languages, 'lang_code'), static::getInstalledLanguages(0)));
379         }
380 
381         // Order the list, if needed.
382         if ($orderField !== null && $orderDirection !== null)
383         {
384             $languages = ArrayHelper::sortObjects($languages, $orderField, strtolower($orderDirection) === 'desc' ? -1 : 1, true, true);
385         }
386 
387         // Add the pivot, if needed.
388         if ($pivot !== null)
389         {
390             $languages = ArrayHelper::pivot($languages, $pivot);
391         }
392 
393         return $languages;
394     }
395 
396     /**
397      * Save strings to a language file.
398      *
399      * @param   string  $filename  The language ini file path.
400      * @param   array   $strings   The array of strings.
401      *
402      * @return  boolean  True if saved, false otherwise.
403      *
404      * @since   3.7.0
405      */
406     public static function saveToIniFile($filename, array $strings)
407     {
408         JLoader::register('JFile', JPATH_LIBRARIES . '/joomla/filesystem/file.php');
409 
410         // Escape double quotes.
411         foreach ($strings as $key => $string)
412         {
413             $strings[$key] = addcslashes($string, '"');
414         }
415 
416         // Write override.ini file with the strings.
417         $registry = new Joomla\Registry\Registry($strings);
418 
419         return JFile::write($filename, $registry->toString('INI'));
420     }
421 
422     /**
423      * Checks if a language exists.
424      *
425      * This is a simple, quick check for the directory that should contain language files for the given user.
426      *
427      * @param   string  $lang      Language to check.
428      * @param   string  $basePath  Optional path to check.
429      *
430      * @return  boolean  True if the language exists.
431      *
432      * @since   3.7.0
433      */
434     public static function exists($lang, $basePath = JPATH_BASE)
435     {
436         static $paths = array();
437 
438         // Return false if no language was specified
439         if (!$lang)
440         {
441             return false;
442         }
443 
444         $path = $basePath . '/language/' . $lang;
445 
446         // Return previous check results if it exists
447         if (isset($paths[$path]))
448         {
449             return $paths[$path];
450         }
451 
452         // Check if the language exists
453         $paths[$path] = is_dir($path);
454 
455         return $paths[$path];
456     }
457 
458     /**
459      * Returns an associative array holding the metadata.
460      *
461      * @param   string  $lang  The name of the language.
462      *
463      * @return  mixed  If $lang exists return key/value pair with the language metadata, otherwise return NULL.
464      *
465      * @since   3.7.0
466      */
467     public static function getMetadata($lang)
468     {
469         $file   = self::getLanguagePath(JPATH_BASE, $lang) . '/' . $lang . '.xml';
470         $result = null;
471 
472         if (is_file($file))
473         {
474             $result = self::parseXMLLanguageFile($file);
475         }
476 
477         if (empty($result))
478         {
479             return;
480         }
481 
482         return $result;
483     }
484 
485     /**
486      * Returns a list of known languages for an area
487      *
488      * @param   string  $basePath  The basepath to use
489      *
490      * @return  array  key/value pair with the language file and real name.
491      *
492      * @since   3.7.0
493      */
494     public static function getKnownLanguages($basePath = JPATH_BASE)
495     {
496         return self::parseLanguageFiles(self::getLanguagePath($basePath));
497     }
498 
499     /**
500      * Get the path to a language
501      *
502      * @param   string  $basePath  The basepath to use.
503      * @param   string  $language  The language tag.
504      *
505      * @return  string  language related path or null.
506      *
507      * @since   3.7.0
508      */
509     public static function getLanguagePath($basePath = JPATH_BASE, $language = null)
510     {
511         return $basePath . '/language' . (!empty($language) ? '/' . $language : '');
512     }
513 
514     /**
515      * Searches for language directories within a certain base dir.
516      *
517      * @param   string  $dir  directory of files.
518      *
519      * @return  array  Array holding the found languages as filename => real name pairs.
520      *
521      * @since   3.7.0
522      */
523     public static function parseLanguageFiles($dir = null)
524     {
525         $languages = array();
526 
527         // Search main language directory for subdirectories
528         foreach (glob($dir . '/*', GLOB_NOSORT | GLOB_ONLYDIR) as $directory)
529         {
530             // But only directories with lang code format
531             if (preg_match('#/[a-z]{2,3}-[A-Z]{2}$#', $directory))
532             {
533                 $dirPathParts = pathinfo($directory);
534                 $file         = $directory . '/' . $dirPathParts['filename'] . '.xml';
535 
536                 if (!is_file($file))
537                 {
538                     continue;
539                 }
540 
541                 try
542                 {
543                     // Get installed language metadata from xml file and merge it with lang array
544                     if ($metadata = self::parseXMLLanguageFile($file))
545                     {
546                         $languages = array_replace($languages, array($dirPathParts['filename'] => $metadata));
547                     }
548                 }
549                 catch (RuntimeException $e)
550                 {
551                 }
552             }
553         }
554 
555         return $languages;
556     }
557 
558     /**
559      * Parse XML file for language information.
560      *
561      * @param   string  $path  Path to the XML files.
562      *
563      * @return  array  Array holding the found metadata as a key => value pair.
564      *
565      * @since   3.7.0
566      * @throws  RuntimeException
567      */
568     public static function parseXMLLanguageFile($path)
569     {
570         if (!is_readable($path))
571         {
572             throw new RuntimeException('File not found or not readable');
573         }
574 
575         // Try to load the file
576         $xml = simplexml_load_file($path);
577 
578         if (!$xml)
579         {
580             return;
581         }
582 
583         // Check that it's a metadata file
584         if ((string) $xml->getName() != 'metafile')
585         {
586             return;
587         }
588 
589         $metadata = array();
590 
591         foreach ($xml->metadata->children() as $child)
592         {
593             $metadata[$child->getName()] = (string) $child;
594         }
595 
596         return $metadata;
597     }
598 }
599 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.