Page MenuHomeIn-Portal Phabricator

multilanguage_helper.php
No OneTemporary

File Metadata

Created
Fri, Nov 20, 6:35 AM

multilanguage_helper.php

<?php
/**
* @version $Id: multilanguage_helper.php 16395 2016-11-12 12:43:14Z alex $
* @package In-Portal
* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
* @license GNU/GPL
* In-Portal is Open Source software.
* This means that this software may have been modified pursuant
* the GNU General Public License, and as distributed it includes
* or is derivative of works licensed under the GNU General Public License
* or other free or open source software licenses.
* See http://www.in-portal.org/license for copyright notices and details.
*/
defined('FULL_PATH') or die('restricted access!');
/**
* Performs action on multilingual fields
*
*/
class kMultiLanguageHelper extends kHelper {
/**
* Determines, that language info should be requeried
*
* @var bool
* @access protected
*/
protected $initMade = false;
/**
* Maximal language id
*
* @var int
*/
protected $languageCount = 0;
/**
* Languages created in system
*
* @var Array
*/
protected $languagesIDs = Array ();
/**
* Structure of table, that is currently processed
*
* @var Array
*/
var $curStructure = Array();
/**
* Field, to get structure information from
*
* @var string
*/
var $curSourceField = false;
/**
* Indexes used in table of 32
*
* @var int
*/
var $curIndexCount = 0;
/**
* Fields from config, that are currently used
*
* @var Array
*/
var $curFields = Array();
public function resetState()
{
$this->initMade = false;
}
/**
* Updates language count in system (always is divisible by 5)
*
*/
protected function _queryLanguages()
{
if ( !$this->initMade ) {
$this->languagesIDs = $this->getActualLanguages();
$this->languageCount = max(max($this->languagesIDs), 5);
$this->initMade = true;
}
}
/**
* Returns language ids, that can be used
*
* @return Array
*/
protected function getActualLanguages()
{
$cache_key = 'actual_language_ids[%LangSerial%]';
$ret = $this->Application->getCache($cache_key);
if ( $ret === false ) {
$this->Conn->nextQueryCachable = true;
$config = $this->Application->getUnitConfig('lang');
$sql = 'SELECT ' . $config->getIDField() . '
FROM ' . $config->getTableName();
$ret = $this->Conn->GetCol($sql);
$this->Application->setCache($cache_key, $ret);
}
return $ret;
}
/**
* Checks if language with specified id is created
*
* @param int $language_id
* @return bool
*/
protected function LanguageFound($language_id)
{
return in_array($language_id, $this->languagesIDs) || $language_id <= 5;
}
/**
* Returns list of processable languages
*
* @return Array
*/
public function getLanguages()
{
$cache_key = 'processable_language_ids[%LangSerial%]';
$ret = $this->Application->getCache($cache_key);
if ( $ret === false ) {
$ret = Array ();
$this->_queryLanguages();
for ($language_id = 1; $language_id <= $this->languageCount; $language_id++) {
if ( $this->LanguageFound($language_id) ) {
$ret[] = $language_id;
}
}
$this->Application->setCache($cache_key, $ret);
}
return $ret;
}
function scanTable($mask)
{
$i = 0;
$fields_found = 0;
$fields = array_keys($this->curStructure);
foreach ($fields as $field_name) {
if (preg_match($mask, $field_name)) {
$fields_found++;
}
}
return $fields_found;
}
function readTableStructure($table_name, $refresh = false)
{
// if ($refresh || !getArrayValue($structure_status, $prefix.'.'.$table_name)) {
$this->curStructure = $this->Conn->Query('DESCRIBE '.$table_name, 'Field');
$this->curIndexCount = count($this->Conn->Query('SHOW INDEXES FROM '.$table_name));
// }
}
/**
* Creates missing multilingual fields for all unit configs, registered in system
*
* @param bool $reread_configs
* @return void
* @access public
*/
public function massCreateFields($reread_configs = true)
{
if ( $reread_configs ) {
$this->Application->UnitConfigReader->ReReadConfigs();
}
foreach ($this->Application->UnitConfigReader->getPrefixes() as $prefix) {
$this->createFields($prefix);
}
}
/**
* Creates missing multilanguage fields in table by specified prefix
*
* @param string $prefix
* @param bool $refresh Forces config field structure to be re-read from database
* @return void
*/
function createFields($prefix, $refresh = false)
{
if ( $refresh && preg_match('/(.*)-cdata$/', $prefix, $regs) ) {
// call main item config to clone cdata table
$this->Application->UnitConfigReader->loadConfig($regs[1]);
$this->Application->UnitConfigReader->runAfterConfigRead($prefix);
}
$config = $this->Application->getUnitConfig($prefix);
$table_name = $config->getTableName();
$this->curFields = $config->getFields();
if ( !($table_name && $this->curFields) || ($table_name && !$this->Conn->TableFound($table_name, kUtil::constOn('IS_INSTALL'))) ) {
// invalid config found or prefix not found
return ;
}
$this->_queryLanguages();
$sqls = Array ();
$this->readTableStructure($table_name, $refresh);
foreach ($this->curFields as $field_name => $field_options) {
if ( getArrayValue($field_options, 'formatter') == 'kMultiLanguage' ) {
if ( isset($field_options['master_field']) ) {
unset($this->curFields[$field_name]);
continue;
}
$this->setSourceField($field_name);
if ( $this->languageCount > 0 ) {
// `l77_Name` VARCHAR( 255 ) NULL DEFAULT '0';
$field_mask = Array ();
$field_mask['name'] = 'l%s_' . $field_name;
$field_mask['null'] = getArrayValue($field_options, 'not_null') ? 'NOT NULL' : 'NULL';
if ( $this->curSourceField ) {
$default_value = $this->getFieldParam('Default') != 'NULL'
? $this->Conn->qstr($this->getFieldParam('Default'))
: $this->getFieldParam('Default');
$field_mask['type'] = $this->getFieldParam('Type');
}
else {
$default_value = is_null($field_options['default']) ? 'NULL'
: $this->Conn->qstr($field_options['default']);
$field_mask['type'] = $field_options['db_type'];
}
$field_mask['default'] = ($field_mask['null'] == 'NOT NULL' && $default_value == 'NULL') ? '' : 'DEFAULT ' . $default_value;
if ( strtoupper($field_mask['type']) == 'TEXT' ) {
// text fields in mysql doesn't have default value
$field_mask = $field_mask['name'] . ' ' . $field_mask['type'] . ' ' . $field_mask['null'];
}
else {
$field_mask = $field_mask['name'] . ' ' . $field_mask['type'] . ' ' . $field_mask['null'] . ' ' . $field_mask['default'];
}
$alter_sqls = $this->generateAlterSQL($field_mask, 1, $this->languageCount);
if ( $alter_sqls ) {
$sqls[] = 'ALTER TABLE ' . $table_name . ' ' . $alter_sqls;
}
}
}
}
foreach ($sqls as $sql_query) {
$this->Conn->Query($sql_query);
}
}
/**
* Creates missing multilanguage fields in table by specified prefix
*
* @param string $prefix
* @param int $src_language
* @param int $dst_language
* @return void
* @access public
*/
public function copyMissingData($prefix, $src_language, $dst_language)
{
$config = $this->Application->getUnitConfig($prefix);
$table_name = $config->getTableName();
$this->curFields = $config->getFields();
if ( !($table_name && $this->curFields) || ($table_name && !$this->Conn->TableFound($table_name, kUtil::constOn('IS_INSTALL'))) ) {
// invalid config found or prefix not found
return ;
}
foreach ($this->curFields as $field_name => $field_options) {
$formatter = isset($field_options['formatter']) ? $field_options['formatter'] : '';
if ( ($formatter == 'kMultiLanguage') && !isset($field_options['master_field']) ) {
$sql = 'UPDATE ' . $table_name . '
SET l' . $dst_language . '_' . $field_name . ' = l' . $src_language . '_' . $field_name . '
WHERE l' . $dst_language . '_' . $field_name . ' = "" OR l' . $dst_language . '_' . $field_name . ' IS NULL';
$this->Conn->Query($sql);
}
}
}
function deleteField($prefix, $custom_id)
{
$table_name = $this->Application->getUnitConfig($prefix)->getTableName();
$sql = 'DESCRIBE '.$table_name.' "l%_cust_'.$custom_id.'"';
$fields = $this->Conn->GetCol($sql);
$sql = 'ALTER TABLE '.$table_name.' ';
$sql_template = 'DROP COLUMN %s, ';
foreach ($fields as $field_name) {
$sql .= sprintf($sql_template, $field_name);
}
$this->Conn->Query( substr($sql, 0, -2) );
}
/**
* Returns parameter requested of current source field
*
* @param string $param_name
* @return string
*/
function getFieldParam($param_name)
{
return $this->curStructure[$this->curSourceField][$param_name];
}
/**
* Detects field name to create other fields from
*
* @param string $field_name
*/
function setSourceField($field_name)
{
$ret = $this->scanTable('/^l[\d]+_'.preg_quote($field_name, '/').'$/');
if (!$ret) {
// no multilingual fields at all (but we have such field without language prefix)
$original_found = $this->scanTable('/^'.preg_quote($field_name, '$/').'/');
$this->curSourceField = $original_found ? $field_name : false;
}
else {
$this->curSourceField = 'l1_'.$field_name;
}
}
/**
* Returns ALTER statement part for adding required fields to table
*
* @param string $field_mask sql mask for creating field with correct definition (type & size)
* @param int $start_index add new fields starting from this index
* @param int $create_count create this much new multilingual field translations
* @return string
*/
function generateAlterSQL($field_mask, $start_index, $create_count)
{
static $single_lang = null;
if (!isset($single_lang)) {
// if single language mode, then create indexes only on primary columns
$table_name = $this->Application->getUnitConfig('lang')->getTableName();
$sql = 'SELECT COUNT(*)
FROM '.$table_name.'
WHERE Enabled = 1';
// if language count = 0, then assume it's multi language mode
$single_lang = $this->Conn->GetOne($sql) == 1;
}
$ret = '';
$ml_field = preg_replace('/l(.*?)_(.*?) (.*)/', '\\2', $field_mask);
$i_count = $start_index + $create_count;
while ($start_index < $i_count) {
if (isset($this->curStructure['l'.$start_index.'_'.$ml_field]) || (!$this->LanguageFound($start_index)) ) {
$start_index++;
continue;
}
$prev_index = $start_index - 1;
do {
list($prev_field,$type) = explode(' ', sprintf($field_mask, $prev_index) );
} while ($prev_index > 0 && !$this->LanguageFound($prev_index--));
if (substr($prev_field, 0, 3) == 'l0_') {
$prev_field = substr($prev_field, 3, strlen($prev_field));
if (!$this->curSourceField) {
// get field name before this one
$fields = array_keys($this->curFields);
// $prev_field = key(end($this->curStructure));
$prev_field = $fields[array_search($prev_field, $fields) - 1];
if (getArrayValue($this->curFields[$prev_field], 'formatter') == 'kMultiLanguage') {
$prev_field = 'l'.$this->languageCount.'_'.$prev_field;
}
}
}
$field_expression = sprintf($field_mask, $start_index);
$ret .= 'ADD COLUMN '.$field_expression.' AFTER `'.$prev_field.'`, ';
if ($this->curIndexCount < 32 && ($start_index == $this->Application->GetDefaultLanguageId() || !$single_lang)) {
// create index for primary language column + for all others (if multiple languages installed)
list($field_name, $field_params) = explode(' ', $field_expression, 2);
if ( isset($this->curFields[$ml_field]['index_type']) ) {
$index_type = $this->curFields[$ml_field]['index_type'];
}
else {
$index_type = 'string';
}
$ret .= $index_type == 'string' ? 'ADD INDEX (`'.$field_name.'` (5) ), ' : 'ADD INDEX (`'.$field_name.'`), ';
$this->curIndexCount++;
}
$start_index++;
}
return preg_replace('/, $/', ';', $ret);
}
/**
* Returns phrase based on given number
*
* @param int $number
* @param Array $forms
* @param bool $allow_editing
* @param bool $use_admin
* @return string
* @access public
*/
public function getPluralPhrase($number, $forms, $allow_editing = true, $use_admin = false)
{
// normalize given forms
if ( !array_key_exists('phrase3', $forms) ) {
$forms['phrase3'] = $forms['phrase2'];
}
if ( !array_key_exists('phrase4', $forms) ) {
$forms['phrase4'] = $forms['phrase2'];
}
if ( !array_key_exists('phrase5', $forms) ) {
$forms['phrase5'] = $forms['phrase2'];
}
$phrase_type = $this->getPluralPhraseType($number);
return $this->Application->Phrase($forms['phrase' . $phrase_type], $allow_editing, $use_admin);
}
/**
* Returns phrase type based on given number
*
* @param int $number
* @return int
* @access protected
*/
protected function getPluralPhraseType($number)
{
$last_digit = substr($number, -1);
$last_but_one_digit = strlen($number) > 1 ? substr($number, -2, 1) : false;
$phrase_type = 5;
if ( $last_but_one_digit != 1 ) {
if ( $last_digit >= 1 && $last_digit <= 4 ) {
$phrase_type = $last_digit;
}
}
return (string)$phrase_type;
}
/**
* Allows usage of
*
* @param kEvent $event
* @return void
* @access public
*/
public function replaceMLCalculatedFields(kEvent $event)
{
$config = $event->getUnitConfig();
$editing_language = $this->getEditingLanguage();
$calculated_fields = $config->getSetting('CalculatedFields', Array ());
/* @var $calculated_fields Array */
foreach ($calculated_fields as $special => $fields) {
foreach ($fields as $field_name => $field_expression) {
$calculated_fields[$special][$field_name] = str_replace('%5$s', $editing_language, $field_expression);
}
}
$config->setSetting('CalculatedFields', $calculated_fields);
}
/**
* Returns language, that is being edited or current language
*
* @return int
* @access public
*/
public function getEditingLanguage()
{
$language_id = $this->Application->GetVar('lang_id');
if ( !$language_id ) {
$language_id = $this->Application->GetVar('m_lang');
}
return $language_id;
}
/**
* Determines if we're editing phrase/e-mail event on it's source language
*
* @param int $source_language
* @return bool
* @access public
*/
public function editingInSourceLanguage($source_language)
{
return $this->getSourceLanguage($source_language) == $this->getEditingLanguage();
}
/**
* Replaces source language in given label translation
*
* @param kDBItem $object
* @param string $label
* @return string
* @access public
*/
public function replaceSourceLanguage(kDBItem $object, $label)
{
$ret = $this->Application->Phrase($label);
$options = $object->GetFieldOption('TranslateFromLanguage', 'options');
$source_language = $this->getSourceLanguage($object->GetDBField('TranslateFromLanguage'));
return sprintf($ret, $options[$source_language]);
}
/**
* Ensures, that primary language is used, when no translation is needed
*
* @param int $source_language
* @return bool
* @access public
*/
public function getSourceLanguage($source_language)
{
if ( !$source_language ) {
$source_language = $this->Application->GetDefaultLanguageId();
}
return $source_language;
}
/**
* Translation synchronization state management
*
* @param kEvent $event
* @return void
* @access public
* @throws InvalidArgumentException
*/
public function updateTranslationState(kEvent $event)
{
if ( $event->Name != 'OnBeforeCopyToLive' ) {
throw new InvalidArgumentException('Unsupported "' . (string)$event . '" event');
}
$object = $event->getObject(Array ('skip_autoload' => true));
/* @var $object kDBItem */
$object->SwitchToTemp();
$object->Load($event->getEventParam('id'));
$save_mode = $this->Application->GetVar('translation_save_mode');
if ( $save_mode === false ) {
return;
}
$editing_language = $this->getEditingLanguage();
if ( $save_mode == TranslationSaveMode::SYNC_WITH_PRIMARY ) {
$object->SetDBField('l' . $editing_language . '_TranslateFrom', 0);
}
else {
$languages = $this->getLanguages();
foreach ($languages as $language_id) {
$object->SetDBField('l' . $language_id . '_TranslateFrom', $language_id == $editing_language ? 0 : $editing_language);
}
}
if ( $object->GetChangedFields() ) {
$object->Update();
}
}
}

Event Timeline