Rocket\Translation\I18N

Complexity

Total Complexity

55

Size/Duplication

Total Lines	496
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Test Coverage

Coverage

39.08%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	30	2
A	getFilePath()	0	3	1
B	getDefaultLanguage()	0	39	8
A	setCurrentLanguage()	0	12	2
A	loadLanguage()	0	18	3
A	getCurrent()	0	4	1
A	getCurrentId()	0	4	1
B	setLanguage()	0	25	6
A	isLoaded()	0	4	1
A	isDefault()	0	8	3
A	isAvailable()	0	4	1
A	languages()	0	20	5
A	languagesForSelect()	0	9	2
A	translateGetString()	0	13	2
A	translateInsertString()	0	18	1
B	translate()	0	35	6
A	getRawStrings()	0	4	1
A	getContext()	0	23	5
A	generate()	0	23	4

<?php

/**
 * Translation management
 */
namespace Rocket\Translation;

use Exception;
use Illuminate\Contracts\Cache\Repository as CacheRepository;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\Session\Session;
use Illuminate\Contracts\Logging\Log;
use Request;
use Rocket\Translation\Model\Language;
use Rocket\Translation\Model\StringModel;
use Rocket\Translation\Model\Translation;

/**
 * Class I18N
 */
class I18N implements I18NInterface
{
    /**
     * An array of the loaded languages
     * @var array
     */
    protected $languagesLoaded = [];

    /**
     * An array of existing languages by ISO
     * @var array
     */
    protected $languagesIso = [];

    /**
     * An array of existing languages by ID
     * @var array
     */
    protected $languagesId = [];

    /**
     * Language currently in use
     * @var string
     */
    protected $currentLanguage;

    /**
     * Language currently in use (ID)
     * @var string
     */
    protected $currentLanguageId;

    /**
     * All the translation strings
     * @var array
     */
    protected $strings = [];

    /**
     * Context of the current page
     * @var string
     */
    protected $pageContext;

    /**
     * Strings cache
     * @var array
     */
    protected $stringsRaw = [];

    /**
     * @var CacheRepository The cache to store the terms in
     */
    protected $cache;

    /**
     * @var Session The session store
     */
    protected $session;

    /**
     * @var Log The log writer
     */
    protected $log;

    /**
     * @var ConfigRepository
     */
    protected $config;

    /**
     * @var Application
     */
    protected $app;

    /**
     * Prepare the translation service
     *
     * @param Application $app
     */
    public function __construct(Application $app, CacheRepository $cache, Session $session, Log $log, ConfigRepository $config)
    {
        $this->app = $app;
        $this->cache = $cache;
        $this->session = $session;
        $this->log = $log;

        $lang = $this->cache->remember(
            'Lang::List',
            60 * 24,
            function () {
                return Language::all();
            }
        );

        foreach ($lang as $l) {
            $this->languagesIso[$l->iso] = $this->languagesId[$l->id] = [
                'id' => $l->id,
                'name' => $l->title,
                'iso' => $l->iso,
            ];
        }

        $locale = $config['app.locale'];
        $fallback = $config['app.fallback_locale'];

        //current default language
        $language = $this->getDefaultLanguage($locale, $fallback);
        $this->setLanguage($language);
    }

    protected function getFilePath() {
        return $this->app['path.storage'] . '/languages/';
    }

    /**
     * Detects the default languages in the following order :
     *
     * 1. Is a user session var defined ?
     * 2. Can we take it from the browser ?
     * 3. Take the site default
     *
     * @param $locale string
     * @param $fallback string
     * @throws Exception if a default language cannot be found
     * @return string
     */
    public function getDefaultLanguage($locale, $fallback)
    {
        //1. detect user session
        $session_lang = $this->session->get('language');

        if (!empty($session_lang)) {
            return $session_lang;
        }

        //TODO :: move languages to subdomains
        //Special workaroud : only french for the moment
        if (defined('F_LANGUAGES') && !F_LANGUAGES) {
            return 'fr';
        }

        //2. detect browser language
        $browser_languages = Request::getLanguages();

        //is one of them available ?
        foreach ($browser_languages as $lang) {
            if ($this->isAvailable($lang)) {
                $this->session->put('language', $lang);

                return $lang;
            }
        }

        //3. Site default
        if ($this->isAvailable($locale)) {
            return $locale;
        }

        //4. Site fallback
        if ($this->isAvailable($fallback)) {
            return $fallback;
        }

        throw new \Exception('Cannot find an adapted language');
    }

    /**
     * Set the current language
     *
     * @param  string $language
     * @return bool
     */
    public function setCurrentLanguage($language)
    {
        if (!$this->isAvailable($language)) {
            return false;
        }

        $this->session->put('language', $language);

        $this->setLanguage($language);

        return true;
    }

    /**
     * Load a language file
     *
     * @param  string $language
     * @return bool
     */
    public function loadLanguage($language)
    {
        if ($this->isLoaded($language)) {
            return;
        }

        $langfile = $language . '.php';

        $this->strings[$language] = [];

        // Determine where the language file is and load it
        $filePath = $this->getFilePath();
        if (file_exists($filePath . $langfile)) {
            $this->strings[$language] = include $filePath . $langfile;
        }

        $this->languagesLoaded[] = $language;
    }

    /**
     * Get the current language
     * @return string
     */
    public function getCurrent()
    {
        return $this->currentLanguage;
    }

    /**
     * Get the current language id
     * @return int
     */
    public function getCurrentId()
    {
        return $this->currentLanguageId;
    }

    /**
     * Set the language to use
     *
     * @param  string $language
     * @return bool
     */
    public function setLanguage($language)
    {
        if ($language == $this->currentLanguage) {
            return;
        }

        if (!$this->isLoaded($language)) {
            $this->loadLanguage($language);
        }

        switch ($language) {
            case 'fr':
                setlocale(LC_ALL, 'fr_FR.utf8', 'fr_FR.UTF-8', 'fr_FR@euro', 'fr_FR', 'french');
                break;
            case 'en':
                setlocale(LC_ALL, 'en_US.utf8', 'en_US.UTF-8', 'en_US');
                break;
            case 'de':
                setlocale(LC_ALL, 'de_DE.utf8', 'de_DE.UTF-8', 'de_DE@euro', 'de_DE', 'deutsch');
                break;
        }

        $this->currentLanguage = $language;
        $this->currentLanguageId = $this->languagesIso[$language]['id'];
    }

    /**
     * Checks if a language is loaded or not
     *
     * @param  string $language
     * @return bool
     */
    protected function isLoaded($language)
    {
        return in_array($language, $this->languagesLoaded);
    }

    /**
     * Checks if a language is the default one
     *
     * @param  string $language
     * @return bool
     */
    protected function isDefault($language)
    {
        if ($language == 'default' or $this->currentLanguage == $language) {
            return true;
        }

        return false;
    }

    /**
     * Checks if the language is availavble
     *
     * @param  string $language
     * @return bool
     */
    protected function isAvailable($language)
    {
        return array_key_exists($language, $this->languagesIso);
    }

    /**
     * Retrieve languages.
     *
     * this is a hybrid method.
     *
     *
     *     I18N::languages();
     *     returns ['fr' => ['id' => 1, 'name' => 'francais', 'iso' => 'fr'], 'en' => ...]
     *
     *
     *     I18N::languages('fr');
     *     returns ['id' => 1, 'name' => 'francais', 'iso' => 'fr']
     *
     *
     *     I18N::languages(1);
     *     returns ['id' => 1, 'name' => 'francais', 'iso' => 'fr']
     *
     *
     *     I18N::languages('fr', 'id');
     *     returns 1
     *
     * @param int|string $key
     * @param string $subkey
     * @return array
     */
    public function languages($key = null, $subkey = null)
    {
        if ($key === null) {
            return $this->languagesIso;
        }

        if (is_int($key)) {
            if (is_null($subkey)) {
                return $this->languagesId[$key];
            }

            return $this->languagesId[$key][$subkey];
        }

        if (is_null($subkey)) {
            return $this->languagesIso[$key];
        }

        return $this->languagesIso[$key][$subkey];
    }

    public function languagesForSelect()
    {
        $languages = [];
        foreach (static::languages() as $lang) {
            $languages[$lang['id']] = t($lang['name'], [], 'languages');
        }

        return $languages;
    }

    protected function translateGetString($context, $language, $string_id)
    {
        $row = Translation::select('text')
            ->where('string_id', $string_id)
            ->where('language_id', $this->languagesIso[$language]['id'])
            ->first();

        if ($row !== null) {
            return $row->text;
        }

        return false;
    }

    protected function translateInsertString($context, $text)
    {
        $string = new StringModel();
        $string->date_creation = mysql_datetime();
        $string->context = $context;
        $string->string = $text;
        $string->save();

        //insertion de la traduction par défaut.
        $translation = new Translation();
        $translation->string_id = $string->id;
        $translation->language_id = $this->languagesIso[$this->config['app.locale']]['id'];
        $translation->date_edition = mysql_datetime();
        $translation->text = $text;
        $translation->save();

        return $translation;
    }

    /**
     * Retreive a string to translate
     *
     * if it doesn't find it, put it in the database
     *
     * @param  string $string
     * @param  string $context
     * @param  string $language
     * @return string
     */
    public function translate($string, $context = 'default', $language = 'default')
    {
        if ($this->isDefault($language)) {
            $language = $this->currentLanguage;
        } else {
            $this->setLanguage($language);
        }

        //get string from cache
        if (array_key_exists($context, $this->strings[$language]) &&
            array_key_exists($string, $this->strings[$language][$context])) {
            return $this->strings[$language][$context][$string];
        }

        //check in db
        $db_string = StringModel::select('id', 'date_creation')
            ->where('string', $string)
            ->where('context', $context)
            ->first();

        if (!$db_string) {
            $this->translateInsertString($context, $string);

            return $string;
        }

        $text = $this->translateGetString($context, $language, $db_string->id);
        if ($text) {
            $this->strings[$language][$context][$string] = $text;

            return $text;
        }

        return $string;
    }

    /**
     * Get the cached strings
     *
     * @return array
     */
    public function getRawStrings()
    {
        return $this->stringsRaw;
    }

    /**
     * Get the page's context
     *
     * @return string
     */
    public function getContext()
    {
        if ($this->pageContext) {
            return $this->pageContext;
        }

        $current = \Route::getCurrentRoute();

        if (!$current) {
            return 'default';
        }

        if ($current->getName()) {
            return $this->pageContext = $current->getName();
        }

        $action = $current->getAction();
        if (array_key_exists('controller', $action)) {
            return $this->pageContext = $action['controller'];
        }

        return $this->pageContext = implode('/', array_map(['Str', 'slug'], explode('/', $current->getUri())));
    }

    public function generate()
    {
        $filePath = $this->getFilePath();

        if (!is_dir($filePath)) {
            mkdir($filePath, 0755, true);
            chmod($filePath, 0755);
        }

        foreach ($this->languages() as $lang => $d) {
            $strings = StringModel::select('string', 'text', 'context')
                ->where('language_id', $d['id'])
                ->join((new Translation)->getTable(), 'strings.id', '=', 'string_id', 'left')
                ->get();

            $final_strings = [];
            foreach ($strings as $s) {
                $final_strings[$s->context][$s->string] = $s->text;
            }

            file_put_contents("{$filePath}{$lang}.php", '<?php return ' . var_export($final_strings, true) . ';');
        }
    }
}