mirror of
https://github.com/silverstripe/silverstripe-framework
synced 2024-07-30 23:43:54 +02:00
dc36725869
MINOR Checking for SiteTree class existence in Security, Translatable MINOR Checking for ContentController existence in FulltextSearchable MINOR Removed unnecessary ContentController tests from ObjectTest MINOR Replaced CMS specific examples in PermissionCheckboxSetFieldTest, DataObjectTest MINOR Changed SecurityTest to make assertions against Security/login rather than relying on redirection from admin/cms
1576 lines
53 KiB
PHP
Executable File
1576 lines
53 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* The Translatable decorator allows your DataObjects to have versions in different languages,
|
|
* defining which fields are can be translated. Translatable can be applied
|
|
* to any {@link DataObject} subclass, but is mostly used with {@link SiteTree}.
|
|
* Translatable is compatible with the {@link Versioned} extension.
|
|
* To avoid cluttering up the database-schema of the 99% of sites without multiple languages,
|
|
* the translation-feature is disabled by default.
|
|
*
|
|
* Locales (e.g. 'en_US') are used in Translatable for identifying a record by language,
|
|
* see section "Locales and Language Tags".
|
|
*
|
|
* <h2>Configuration</h2>
|
|
*
|
|
* <h3>Through Object::add_extension()</h3>
|
|
* Enabling Translatable through {@link Object::add_extension()} in your _config.php:
|
|
* <code>
|
|
* Object::add_extension('MyClass', 'Translatable');
|
|
* </code>
|
|
* This is the recommended approach for enabling Translatable.
|
|
*
|
|
* <h3>Through $extensions</h3>
|
|
* <code>
|
|
* class MyClass extends DataObject {
|
|
* static $extensions = array(
|
|
* "Translatable"
|
|
* );
|
|
* }
|
|
* </code>
|
|
*
|
|
* Make sure to rebuild the database through /dev/build after enabling translatable.
|
|
* Use the correct {@link set_default_locale()} before building the database
|
|
* for the first time, as this locale will be written on all new records.
|
|
*
|
|
* <h3>"Default" locales</h3>
|
|
*
|
|
* Important: If the "default language" of your site is not US-English (en_US),
|
|
* please ensure to set the appropriate default language for
|
|
* your content before building the database with Translatable enabled:
|
|
* <code>
|
|
* Translatable::set_default_locale(<locale>); // e.g. 'de_DE' or 'fr_FR'
|
|
* </code>
|
|
*
|
|
* For the Translatable class, a "locale" consists of a language code plus a region code separated by an underscore,
|
|
* for example "de_AT" for German language ("de") in the region Austria ("AT").
|
|
* See http://www.w3.org/International/articles/language-tags/ for a detailed description.
|
|
*
|
|
* <h2>Usage</h2>
|
|
*
|
|
* Getting a translation for an existing instance:
|
|
* <code>
|
|
* $translatedObj = Translatable::get_one_by_locale('MyObject', 'de_DE');
|
|
* </code>
|
|
*
|
|
* Getting a translation for an existing instance:
|
|
* <code>
|
|
* $obj = DataObject::get_by_id('MyObject', 99); // original language
|
|
* $translatedObj = $obj->getTranslation('de_DE');
|
|
* </code>
|
|
*
|
|
* Getting translations through {@link Translatable::set_current_locale()}.
|
|
* This is *not* a recommended approach, but sometimes inavoidable (e.g. for {@link Versioned} methods).
|
|
* <code>
|
|
* $origLocale = Translatable::get_current_locale();
|
|
* Translatable::set_current_locale('de_DE');
|
|
* $obj = Versioned::get_one_by_stage('MyObject', "ID = 99");
|
|
* Translatable::set_current_locale($origLocale);
|
|
* </code>
|
|
*
|
|
* Creating a translation:
|
|
* <code>
|
|
* $obj = new MyObject();
|
|
* $translatedObj = $obj->createTranslation('de_DE');
|
|
* </code>
|
|
*
|
|
* <h2>Usage for SiteTree</h2>
|
|
*
|
|
* Translatable can be used for subclasses of {@link SiteTree} as well.
|
|
*
|
|
* <code>
|
|
* Object::add_extension('SiteTree', 'Translatable');
|
|
* Object::add_extension('SiteConig', 'Translatable');
|
|
* </code>
|
|
*
|
|
* If a child page translation is requested without the parent
|
|
* page already having a translation in this language, the extension
|
|
* will recursively create translations up the tree.
|
|
* Caution: The "URLSegment" property is enforced to be unique across
|
|
* languages by auto-appending the language code at the end.
|
|
* You'll need to ensure that the appropriate "reading language" is set
|
|
* before showing links to other pages on a website through $_GET['locale'].
|
|
* Pages in different languages can have different publication states
|
|
* through the {@link Versioned} extension.
|
|
*
|
|
* Note: You can't get Children() for a parent page in a different language
|
|
* through set_current_locale(). Get the translated parent first.
|
|
*
|
|
* <code>
|
|
* // wrong
|
|
* Translatable::set_current_locale('de_DE');
|
|
* $englishParent->Children();
|
|
* // right
|
|
* $germanParent = $englishParent->getTranslation('de_DE');
|
|
* $germanParent->Children();
|
|
* </code>
|
|
*
|
|
* <h2>Translation groups</h2>
|
|
*
|
|
* Each translation can have one or more related pages in other languages.
|
|
* This relation is optional, meaning you can
|
|
* create translations which have no representation in the "default language".
|
|
* This means you can have a french translation with a german original,
|
|
* without either of them having a representation
|
|
* in the default english language tree.
|
|
* Caution: There is no versioning for translation groups,
|
|
* meaning associating an object with a group will affect both stage and live records.
|
|
*
|
|
* SiteTree database table (abbreviated)
|
|
* ^ ID ^ URLSegment ^ Title ^ Locale ^
|
|
* | 1 | about-us | About us | en_US |
|
|
* | 2 | ueber-uns | Über uns | de_DE |
|
|
* | 3 | contact | Contact | en_US |
|
|
*
|
|
* SiteTree_translationgroups database table
|
|
* ^ TranslationGroupID ^ OriginalID ^
|
|
* | 99 | 1 |
|
|
* | 99 | 2 |
|
|
* | 199 | 3 |
|
|
*
|
|
* <h2>Character Sets</h2>
|
|
*
|
|
* Caution: Does not apply any character-set conversion, it is assumed that all content
|
|
* is stored and represented in UTF-8 (Unicode). Please make sure your database and
|
|
* HTML-templates adjust to this.
|
|
*
|
|
* <h2>Permissions</h2>
|
|
*
|
|
* Authors without administrative access need special permissions to edit locales other than
|
|
* the default locale.
|
|
*
|
|
* - TRANSLATE_ALL: Translate into all locales
|
|
* - Translate_<locale>: Translate a specific locale. Only available for all locales set in
|
|
* `Translatable::set_allowed_locales()`.
|
|
*
|
|
* Note: If user-specific view permissions are required, please overload `SiteTree->canView()`.
|
|
*
|
|
* <h2>Uninstalling/Disabling</h2>
|
|
*
|
|
* Disabling Translatable after creating translations will lead to all
|
|
* pages being shown in the default sitetree regardless of their language.
|
|
* It is advised to start with a new database after uninstalling Translatable,
|
|
* or manually filter out translated objects through their "Locale" property
|
|
* in the database.
|
|
*
|
|
* @see http://doc.silverstripe.org/doku.php?id=multilingualcontent
|
|
*
|
|
* @author Ingo Schommer <ingo (at) silverstripe (dot) com>
|
|
* @author Michael Gall <michael (at) wakeless (dot) net>
|
|
* @author Bernat Foj Capell <bernat@silverstripe.com>
|
|
*
|
|
* @package sapphire
|
|
* @subpackage i18n
|
|
*/
|
|
class Translatable extends DataObjectDecorator implements PermissionProvider {
|
|
|
|
/**
|
|
* The 'default' language.
|
|
* @var string
|
|
*/
|
|
protected static $default_locale = 'en_US';
|
|
|
|
/**
|
|
* The language in which we are reading dataobjects.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected static $current_locale = null;
|
|
|
|
/**
|
|
* A cached list of existing tables
|
|
*
|
|
* @var mixed
|
|
*/
|
|
protected static $tableList = null;
|
|
|
|
/**
|
|
* An array of fields that can be translated.
|
|
* @var array
|
|
*/
|
|
protected $translatableFields = null;
|
|
|
|
/**
|
|
* A map of the field values of the original (untranslated) DataObject record
|
|
* @var array
|
|
*/
|
|
protected $original_values = null;
|
|
|
|
/**
|
|
* If this is set to TRUE then {@link augmentSQL()} will automatically add a filter
|
|
* clause to limit queries to the current {@link get_current_locale()}. This camn be
|
|
* disabled using {@link disable_locale_filter()}
|
|
*
|
|
* @var bool
|
|
*/
|
|
protected static $locale_filter_enabled = true;
|
|
|
|
/**
|
|
* @var array All locales in which a translation can be created.
|
|
* This limits the choice in the CMS language dropdown in the
|
|
* "Translation" tab, as well as the language dropdown above
|
|
* the CMS tree. If not set, it will default to showing all
|
|
* common locales.
|
|
*/
|
|
protected static $allowed_locales = null;
|
|
|
|
/**
|
|
* Reset static configuration variables to their default values
|
|
*/
|
|
static function reset() {
|
|
self::enable_locale_filter();
|
|
self::$default_locale = 'en_US';
|
|
self::$current_locale = null;
|
|
self::$allowed_locales = null;
|
|
}
|
|
|
|
/**
|
|
* Choose the language the site is currently on.
|
|
*
|
|
* If $_GET['locale'] is currently set, then that locale will be used. Otherwise the member preference (if logged
|
|
* in) or default locale will be used.
|
|
*
|
|
* @todo Re-implement cookie and member option
|
|
*
|
|
* @param $langsAvailable array A numerical array of languages which are valid choices (optional)
|
|
* @return string Selected language (also saved in $current_locale).
|
|
*/
|
|
static function choose_site_locale($langsAvailable = array()) {
|
|
if(self::$current_locale) {
|
|
return self::$current_locale;
|
|
}
|
|
|
|
if((isset($_GET['locale']) && !$langsAvailable) || (isset($_GET['locale']) && in_array($_GET['locale'], $langsAvailable))) {
|
|
// get from GET parameter
|
|
self::set_current_locale($_GET['locale']);
|
|
} else {
|
|
self::set_current_locale(self::default_locale());
|
|
}
|
|
|
|
return self::$current_locale;
|
|
}
|
|
|
|
/**
|
|
* Get the current reading language.
|
|
* This value has to be set before the schema is built with translatable enabled,
|
|
* any changes after this can cause unintended side-effects.
|
|
*
|
|
* @return string
|
|
*/
|
|
static function default_locale() {
|
|
return self::$default_locale;
|
|
}
|
|
|
|
/**
|
|
* Set default language. Please set this value *before* creating
|
|
* any database records (like pages), as this locale will be attached
|
|
* to all new records.
|
|
*
|
|
* @param $locale String
|
|
*/
|
|
static function set_default_locale($locale) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
$localeList = i18n::get_locale_list();
|
|
if(isset($localeList[$locale])) {
|
|
self::$default_locale = $locale;
|
|
} else {
|
|
user_error("Translatable::set_default_locale(): '$locale' is not a valid locale.", E_USER_WARNING);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the current reading language.
|
|
* If its not chosen, call {@link choose_site_locale()}.
|
|
*
|
|
* @return string
|
|
*/
|
|
static function get_current_locale() {
|
|
return (self::$current_locale) ? self::$current_locale : self::choose_site_locale();
|
|
}
|
|
|
|
/**
|
|
* Set the reading language, either namespaced to 'site' (website content)
|
|
* or 'cms' (management backend). This value is used in {@link augmentSQL()}
|
|
* to "auto-filter" all SELECT queries by this language.
|
|
* See {@link disable_locale_filter()} on how to override this behaviour temporarily.
|
|
*
|
|
* @param string $lang New reading language.
|
|
*/
|
|
static function set_current_locale($locale) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
self::$current_locale = $locale;
|
|
}
|
|
|
|
/**
|
|
* Get a singleton instance of a class in the given language.
|
|
* @param string $class The name of the class.
|
|
* @param string $locale The name of the language.
|
|
* @param string $filter A filter to be inserted into the WHERE clause.
|
|
* @param boolean $cache Use caching (default: false)
|
|
* @param string $orderby A sort expression to be inserted into the ORDER BY clause.
|
|
* @return DataObject
|
|
*/
|
|
static function get_one_by_locale($class, $locale, $filter = '', $cache = false, $orderby = "") {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
$orig = Translatable::get_current_locale();
|
|
Translatable::set_current_locale($locale);
|
|
$do = DataObject::get_one($class, $filter, $cache, $orderby);
|
|
Translatable::set_current_locale($orig);
|
|
return $do;
|
|
}
|
|
|
|
/**
|
|
* Get all the instances of the given class translated to the given language
|
|
*
|
|
* @param string $class The name of the class
|
|
* @param string $locale The name of the language
|
|
* @param string $filter A filter to be inserted into the WHERE clause.
|
|
* @param string $sort A sort expression to be inserted into the ORDER BY clause.
|
|
* @param string $join A single join clause. This can be used for filtering, only 1 instance of each DataObject will be returned.
|
|
* @param string $limit A limit expression to be inserted into the LIMIT clause.
|
|
* @param string $containerClass The container class to return the results in.
|
|
* @param string $having A filter to be inserted into the HAVING clause.
|
|
* @return mixed The objects matching the conditions.
|
|
*/
|
|
static function get_by_locale($class, $locale, $filter = '', $sort = '', $join = "", $limit = "", $containerClass = "DataObjectSet", $having = "") {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
$oldLang = self::get_current_locale();
|
|
self::set_current_locale($locale);
|
|
$result = DataObject::get($class, $filter, $sort, $join, $limit, $containerClass, $having);
|
|
self::set_current_locale($oldLang);
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public static function locale_filter_enabled() {
|
|
return self::$locale_filter_enabled;
|
|
}
|
|
|
|
/**
|
|
* Enables automatic filtering by locale. This is normally called after is has been
|
|
* disabled using {@link disable_locale_filter()}.
|
|
*/
|
|
public static function enable_locale_filter() {
|
|
self::$locale_filter_enabled = true;
|
|
}
|
|
|
|
/**
|
|
* Disables automatic locale filtering in {@link augmentSQL()}. This can be re-enabled
|
|
* using {@link enable_locale_filter()}.
|
|
*/
|
|
public static function disable_locale_filter() {
|
|
self::$locale_filter_enabled = false;
|
|
}
|
|
|
|
/**
|
|
* Gets all translations for this specific page.
|
|
* Doesn't include the language of the current record.
|
|
*
|
|
* @return array Numeric array of all locales, sorted alphabetically.
|
|
*/
|
|
function getTranslatedLocales() {
|
|
$langs = array();
|
|
|
|
$baseDataClass = ClassInfo::baseDataClass($this->owner->class); //Base Class
|
|
$translationGroupClass = $baseDataClass . "_translationgroups";
|
|
if($this->owner->hasExtension("Versioned") && Versioned::current_stage() == "Live") {
|
|
$baseDataClass = $baseDataClass . "_Live";
|
|
}
|
|
|
|
$translationGroupID = $this->getTranslationGroup();
|
|
if(is_numeric($translationGroupID)) {
|
|
$query = new SQLQuery(
|
|
'DISTINCT "Locale"',
|
|
sprintf(
|
|
'"%s" LEFT JOIN "%s" ON "%s"."OriginalID" = "%s"."ID"',
|
|
$baseDataClass,
|
|
$translationGroupClass,
|
|
$translationGroupClass,
|
|
$baseDataClass
|
|
), // from
|
|
sprintf(
|
|
'"%s"."TranslationGroupID" = %d AND "%s"."Locale" != \'%s\'',
|
|
$translationGroupClass,
|
|
$translationGroupID,
|
|
$baseDataClass,
|
|
$this->owner->Locale
|
|
) // where
|
|
);
|
|
$langs = $query->execute()->column();
|
|
}
|
|
if($langs) {
|
|
$langCodes = array_values($langs);
|
|
sort($langCodes);
|
|
return $langCodes;
|
|
} else {
|
|
return array();
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Gets all locales that a member can access
|
|
* as defined by {@link $allowed_locales}
|
|
* and {@link canTranslate()}.
|
|
* If {@link $allowed_locales} is not set and
|
|
* the user has the `TRANSLATE_ALL` permission,
|
|
* the method will return all available locales in the system.
|
|
*
|
|
* @param Member $member
|
|
* @return array Map of locales
|
|
*/
|
|
function getAllowedLocalesForMember($member) {
|
|
$locales = self::get_allowed_locales();
|
|
if(!$locales) $locales = i18n::get_common_locales();
|
|
if($locales) foreach($locales as $k => $locale) {
|
|
if(!$this->canTranslate($member, $locale)) unset($locales[$k]);
|
|
}
|
|
|
|
return $locales;
|
|
}
|
|
|
|
/**
|
|
* Get a list of languages in which a given element has been translated.
|
|
*
|
|
* @deprecated 2.4 Use {@link getTranslations()}
|
|
*
|
|
* @param string $class Name of the class of the element
|
|
* @param int $id ID of the element
|
|
* @return array List of languages
|
|
*/
|
|
static function get_langs_by_id($class, $id) {
|
|
$do = DataObject::get_by_id($class, $id);
|
|
return ($do ? $do->getTranslatedLocales() : array());
|
|
}
|
|
|
|
/**
|
|
* Enables the multilingual feature
|
|
*
|
|
* @deprecated 2.4 Use Object::add_extension('SiteTree', 'Translatable')
|
|
*/
|
|
static function enable() {
|
|
if(class_exists('SiteTree')) Object::add_extension('SiteTree', 'Translatable');
|
|
}
|
|
|
|
/**
|
|
* Disable the multilingual feature
|
|
*
|
|
* @deprecated 2.4 Use Object::remove_extension('SiteTree', 'Translatable')
|
|
*/
|
|
static function disable() {
|
|
if(class_exists('SiteTree')) Object::remove_extension('SiteTree', 'Translatable');
|
|
}
|
|
|
|
/**
|
|
* Check whether multilingual support has been enabled
|
|
*
|
|
* @deprecated 2.4 Use Object::has_extension('SiteTree', 'Translatable')
|
|
* @return boolean True if enabled
|
|
*/
|
|
static function is_enabled() {
|
|
if(class_exists('SiteTree')){
|
|
return Object::has_extension('SiteTree', 'Translatable');
|
|
}else{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Construct a new Translatable object.
|
|
* @var array $translatableFields The different fields of the object that can be translated.
|
|
* This is currently not implemented, all fields are marked translatable (see {@link setOwner()}).
|
|
*/
|
|
function __construct($translatableFields = null) {
|
|
parent::__construct();
|
|
|
|
// @todo Disabled selection of translatable fields - we're setting all fields as translatable in setOwner()
|
|
/*
|
|
if(!is_array($translatableFields)) {
|
|
$translatableFields = func_get_args();
|
|
}
|
|
$this->translatableFields = $translatableFields;
|
|
*/
|
|
|
|
// workaround for extending a method on another decorator (Hierarchy):
|
|
// split the method into two calls, and overwrite the wrapper AllChildrenIncludingDeleted()
|
|
// Has to be executed even with Translatable disabled, as it overwrites the method with same name
|
|
// on Hierarchy class, and routes through to Hierarchy->doAllChildrenIncludingDeleted() instead.
|
|
// Caution: There's an additional method for augmentAllChildrenIncludingDeleted()
|
|
|
|
}
|
|
|
|
function setOwner($owner, $ownerBaseClass = null) {
|
|
parent::setOwner($owner, $ownerBaseClass);
|
|
|
|
// setting translatable fields by inspecting owner - this should really be done in the constructor
|
|
if($this->owner && $this->translatableFields === null) {
|
|
$this->translatableFields = array_merge(
|
|
array_keys($this->owner->inheritedDatabaseFields()),
|
|
array_keys($this->owner->has_many()),
|
|
array_keys($this->owner->many_many())
|
|
);
|
|
}
|
|
}
|
|
|
|
function extraStatics() {
|
|
return array(
|
|
"db" => array(
|
|
"Locale" => "DBLocale",
|
|
//"TranslationMasterID" => "Int" // optional relation to a "translation master"
|
|
),
|
|
"defaults" => array(
|
|
"Locale" => Translatable::default_locale() // as an overloaded getter as well: getLang()
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Changes any SELECT query thats not filtering on an ID
|
|
* to limit by the current language defined in {@link get_current_locale()}.
|
|
* It falls back to "Locale='' OR Lang IS NULL" and assumes that
|
|
* this implies querying for the default language.
|
|
*
|
|
* Use {@link disable_locale_filter()} to temporarily disable this "auto-filtering".
|
|
*/
|
|
function augmentSQL(SQLQuery &$query) {
|
|
// If the record is saved (and not a singleton), and has a locale,
|
|
// limit the current call to its locale. This fixes a lot of problems
|
|
// with other extensions like Versioned
|
|
$locale = ($this->owner->ID && $this->owner->Locale) ? $this->owner->Locale : Translatable::get_current_locale();
|
|
$baseTable = ClassInfo::baseDataClass($this->owner->class);
|
|
$where = $query->where;
|
|
if(
|
|
$locale
|
|
// unless the filter has been temporarily disabled
|
|
&& self::locale_filter_enabled()
|
|
// DataObject::get_by_id() should work independently of language
|
|
&& !$query->filtersOnID()
|
|
// the query contains this table
|
|
// @todo Isn't this always the case?!
|
|
&& array_search($baseTable, array_keys($query->from)) !== false
|
|
// or we're already filtering by Lang (either from an earlier augmentSQL() call or through custom SQL filters)
|
|
&& !preg_match('/("|\'|`)Locale("|\'|`)/', $query->getFilter())
|
|
//&& !$query->filtersOnFK()
|
|
) {
|
|
$qry = sprintf('"%s"."Locale" = \'%s\'', $baseTable, Convert::raw2sql($locale));
|
|
$query->where[] = $qry;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create <table>_translation database table to enable
|
|
* tracking of "translation groups" in which each related
|
|
* translation of an object acts as a sibling, rather than
|
|
* a parent->child relation.
|
|
*/
|
|
function augmentDatabase() {
|
|
$baseDataClass = ClassInfo::baseDataClass($this->owner->class);
|
|
if($this->owner->class != $baseDataClass) return;
|
|
|
|
$fields = array(
|
|
'OriginalID' => 'Int',
|
|
'TranslationGroupID' => 'Int',
|
|
);
|
|
$indexes = array(
|
|
'OriginalID' => true,
|
|
'TranslationGroupID' => true
|
|
);
|
|
|
|
// Add new tables if required
|
|
DB::requireTable("{$baseDataClass}_translationgroups", $fields, $indexes);
|
|
|
|
// Remove 2.2 style tables
|
|
DB::dontRequireTable("{$baseDataClass}_lang");
|
|
if($this->owner->hasExtension('Versioned')) {
|
|
DB::dontRequireTable("{$baseDataClass}_lang_Live");
|
|
DB::dontRequireTable("{$baseDataClass}_lang_versions");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @todo Find more appropriate place to hook into database building
|
|
*/
|
|
function requireDefaultRecords() {
|
|
// @todo This relies on the Locale attribute being on the base data class, and not any subclasses
|
|
if($this->owner->class != ClassInfo::baseDataClass($this->owner->class)) return false;
|
|
|
|
// Permissions: If a group doesn't have any specific TRANSLATE_<locale> edit rights,
|
|
// but has CMS_ACCESS_CMSMain (general CMS access), then assign TRANSLATE_ALL permissions as a default.
|
|
// Auto-setting permissions based on these intransparent criteria is a bit hacky,
|
|
// but unavoidable until we can determine when a certain permission code was made available first
|
|
// (see http://open.silverstripe.org/ticket/4940)
|
|
$groups = Permission::get_groups_by_permission(array('CMS_ACCESS_CMSMain','CMS_ACCESS_LeftAndMain','ADMIN'));
|
|
if($groups) foreach($groups as $group) {
|
|
$codes = $group->Permissions()->column('Code');
|
|
$hasTranslationCode = false;
|
|
foreach($codes as $code) {
|
|
if(preg_match('/^TRANSLATE_/', $code)) $hasTranslationCode = true;
|
|
}
|
|
// Only add the code if no more restrictive code exists
|
|
if(!$hasTranslationCode) Permission::grant($group->ID, 'TRANSLATE_ALL');
|
|
}
|
|
|
|
// If the Translatable extension was added after the first records were already
|
|
// created in the database, make sure to update the Locale property if
|
|
// if wasn't set before
|
|
$idsWithoutLocale = DB::query(sprintf(
|
|
'SELECT "ID" FROM "%s" WHERE "Locale" IS NULL OR "Locale" = \'\'',
|
|
ClassInfo::baseDataClass($this->owner->class)
|
|
))->column();
|
|
if(!$idsWithoutLocale) return;
|
|
|
|
if(class_exists('SiteTree') && $this->owner->class == 'SiteTree') {
|
|
foreach(array('Stage', 'Live') as $stage) {
|
|
foreach($idsWithoutLocale as $id) {
|
|
$obj = Versioned::get_one_by_stage(
|
|
$this->owner->class,
|
|
$stage,
|
|
sprintf('"SiteTree"."ID" = %d', $id)
|
|
);
|
|
if(!$obj) continue;
|
|
|
|
$obj->Locale = Translatable::default_locale();
|
|
$obj->writeToStage($stage);
|
|
$obj->addTranslationGroup($obj->ID);
|
|
$obj->destroy();
|
|
unset($obj);
|
|
}
|
|
}
|
|
} else {
|
|
foreach($idsWithoutLocale as $id) {
|
|
$obj = DataObject::get_by_id($this->owner->class, $id);
|
|
if(!$obj) continue;
|
|
|
|
$obj->Locale = Translatable::default_locale();
|
|
$obj->write();
|
|
$obj->addTranslationGroup($obj->ID);
|
|
$obj->destroy();
|
|
unset($obj);
|
|
}
|
|
}
|
|
DB::alteration_message(sprintf(
|
|
"Added default locale '%s' to table %s","changed",
|
|
Translatable::default_locale(),
|
|
$this->owner->class
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Add a record to a "translation group",
|
|
* so its relationship to other translations
|
|
* based off the same object can be determined later on.
|
|
* See class header for further comments.
|
|
*
|
|
* @param int $originalID Either the primary key of the record this new translation is based on,
|
|
* or the primary key of this record, to create a new translation group
|
|
* @param boolean $overwrite
|
|
*/
|
|
public function addTranslationGroup($originalID, $overwrite = false) {
|
|
if(!$this->owner->exists()) return false;
|
|
|
|
$baseDataClass = ClassInfo::baseDataClass($this->owner->class);
|
|
$existingGroupID = $this->getTranslationGroup($originalID);
|
|
|
|
// Remove any existing groups if overwrite flag is set
|
|
if($existingGroupID && $overwrite) {
|
|
$sql = sprintf(
|
|
'DELETE FROM "%s_translationgroups" WHERE "TranslationGroupID" = %d AND "OriginalID" = %d',
|
|
$baseDataClass,
|
|
$existingGroupID,
|
|
$this->owner->ID
|
|
);
|
|
DB::query($sql);
|
|
$existingGroupID = null;
|
|
}
|
|
|
|
// Add to group (only if not in existing group or $overwrite flag is set)
|
|
if(!$existingGroupID) {
|
|
$sql = sprintf(
|
|
'INSERT INTO "%s_translationgroups" ("TranslationGroupID","OriginalID") VALUES (%d,%d)',
|
|
$baseDataClass,
|
|
$originalID,
|
|
$this->owner->ID
|
|
);
|
|
DB::query($sql);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the translation group for the current record.
|
|
* This ID might equal the record ID, but doesn't have to -
|
|
* it just points to one "original" record in the list.
|
|
*
|
|
* @return int Numeric ID of the translationgroup in the <classname>_translationgroup table
|
|
*/
|
|
public function getTranslationGroup() {
|
|
if(!$this->owner->exists()) return false;
|
|
|
|
$baseDataClass = ClassInfo::baseDataClass($this->owner->class);
|
|
return DB::query(
|
|
sprintf('SELECT "TranslationGroupID" FROM "%s_translationgroups" WHERE "OriginalID" = %d', $baseDataClass, $this->owner->ID)
|
|
)->value();
|
|
}
|
|
|
|
/**
|
|
* Removes a record from the translation group lookup table.
|
|
* Makes no assumptions on other records in the group - meaning
|
|
* if this happens to be the last record assigned to the group,
|
|
* this group ceases to exist.
|
|
*/
|
|
public function removeTranslationGroup() {
|
|
$baseDataClass = ClassInfo::baseDataClass($this->owner->class);
|
|
DB::query(
|
|
sprintf('DELETE FROM "%s_translationgroups" WHERE "OriginalID" = %d', $baseDataClass, $this->owner->ID)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Determine if a table needs Versioned support
|
|
* This is called at db/build time
|
|
*
|
|
* @param string $table Table name
|
|
* @return boolean
|
|
*/
|
|
function isVersionedTable($table) {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Note: The bulk of logic is in ModelAsController->getNestedController()
|
|
* and ContentController->handleRequest()
|
|
*/
|
|
function contentcontrollerInit($controller) {
|
|
$controller->Locale = Translatable::choose_site_locale();
|
|
}
|
|
|
|
function modelascontrollerInit($controller) {
|
|
//$this->contentcontrollerInit($controller);
|
|
}
|
|
|
|
function initgetEditForm($controller) {
|
|
$this->contentcontrollerInit($controller);
|
|
}
|
|
|
|
/**
|
|
* Recursively creates translations for parent pages in this language
|
|
* if they aren't existing already. This is a necessity to make
|
|
* nested pages accessible in a translated CMS page tree.
|
|
* It would be more userfriendly to grey out untranslated pages,
|
|
* but this involves complicated special cases in AllChildrenIncludingDeleted().
|
|
*
|
|
* {@link SiteTree->onBeforeWrite()} will ensure that each translation will get
|
|
* a unique URL across languages, by means of {@link SiteTree::get_by_link()}
|
|
* and {@link Translatable->alternateGetByURL()}.
|
|
*/
|
|
function onBeforeWrite() {
|
|
// If language is not set explicitly, set it to current_locale.
|
|
// This might be a bit overzealous in assuming the language
|
|
// of the content, as a "single language" website might be expanded
|
|
// later on. See {@link requireDefaultRecords()} for batch setting
|
|
// of empty Locale columns on each dev/build call.
|
|
if(!$this->owner->Locale) {
|
|
$this->owner->Locale = Translatable::get_current_locale();
|
|
}
|
|
|
|
// Specific logic for SiteTree subclasses.
|
|
// If page has untranslated parents, create (unpublished) translations
|
|
// of those as well to avoid having inaccessible children in the sitetree.
|
|
// Caution: This logic is very sensitve to infinite loops when translation status isn't determined properly
|
|
// If a parent for the newly written translation was existing before this
|
|
// onBeforeWrite() call, it will already have been linked correctly through createTranslation()
|
|
if(class_exists('SiteTree') && $this->owner->hasField('ParentID') && $this->owner instanceof SiteTree) {
|
|
if(
|
|
!$this->owner->ID
|
|
&& $this->owner->ParentID
|
|
&& !$this->owner->Parent()->hasTranslation($this->owner->Locale)
|
|
) {
|
|
$parentTranslation = $this->owner->Parent()->createTranslation($this->owner->Locale);
|
|
$this->owner->ParentID = $parentTranslation->ID;
|
|
}
|
|
}
|
|
|
|
// Has to be limited to the default locale, the assumption is that the "page type"
|
|
// dropdown is readonly on all translations.
|
|
if($this->owner->ID && $this->owner->Locale == Translatable::default_locale()) {
|
|
$changedFields = $this->owner->getChangedFields();
|
|
if(isset($changedFields['ClassName'])) {
|
|
$this->owner->ClassName = $changedFields['ClassName']['before'];
|
|
$translations = $this->owner->getTranslations();
|
|
$this->owner->ClassName = $changedFields['ClassName']['after'];
|
|
if($translations) foreach($translations as $translation) {
|
|
$translation->setClassName($this->owner->ClassName);
|
|
$translation = $translation->newClassInstance($translation->ClassName);
|
|
$translation->populateDefaults();
|
|
$translation->forceChange();
|
|
$translation->write();
|
|
}
|
|
}
|
|
}
|
|
|
|
// see onAfterWrite()
|
|
if(!$this->owner->ID) {
|
|
$this->owner->_TranslatableIsNewRecord = true;
|
|
}
|
|
}
|
|
|
|
function onAfterWrite() {
|
|
// hacky way to determine if the record was created in the database,
|
|
// or just updated
|
|
if($this->owner->_TranslatableIsNewRecord) {
|
|
// this would kick in for all new records which are NOT
|
|
// created through createTranslation(), meaning they don't
|
|
// have the translation group automatically set.
|
|
$translationGroupID = $this->getTranslationGroup();
|
|
if(!$translationGroupID) $this->addTranslationGroup($this->owner->_TranslationGroupID ? $this->owner->_TranslationGroupID : $this->owner->ID);
|
|
unset($this->owner->_TranslatableIsNewRecord);
|
|
unset($this->owner->_TranslationGroupID);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Remove the record from the translation group mapping.
|
|
*/
|
|
function onBeforeDelete() {
|
|
// @todo Coupling to Versioned, we need to avoid removing
|
|
// translation groups if records are just deleted from a stage
|
|
// (="unpublished"). Ideally the translation group tables would
|
|
// be specific to different Versioned changes, making this restriction unnecessary.
|
|
// This will produce orphaned translation group records for SiteTree subclasses.
|
|
if(!$this->owner->hasExtension('Versioned')) {
|
|
$this->removeTranslationGroup();
|
|
}
|
|
|
|
parent::onBeforeDelete();
|
|
}
|
|
|
|
/**
|
|
* Attempt to get the page for a link in the default language that has been translated.
|
|
*
|
|
* @param string $URLSegment
|
|
* @param int|null $parentID
|
|
* @return SiteTree
|
|
*/
|
|
public function alternateGetByLink($URLSegment, $parentID) {
|
|
// If the parentID value has come from a translated page, then we need to find the corresponding parentID value
|
|
// in the default Locale.
|
|
if (
|
|
is_int($parentID)
|
|
&& $parentID > 0
|
|
&& ($parent = DataObject::get_by_id('SiteTree', $parentID))
|
|
&& ($parent->isTranslation())
|
|
) {
|
|
$parentID = $parent->getTranslationGroup();
|
|
}
|
|
|
|
// Find the locale language-independent of the page
|
|
self::disable_locale_filter();
|
|
$default = DataObject::get_one (
|
|
'SiteTree',
|
|
sprintf (
|
|
'"URLSegment" = \'%s\'%s',
|
|
Convert::raw2sql($URLSegment),
|
|
(is_int($parentID) ? " AND \"ParentID\" = $parentID" : null)
|
|
),
|
|
false
|
|
);
|
|
self::enable_locale_filter();
|
|
|
|
return $default;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------//
|
|
|
|
/**
|
|
* If the record is not shown in the default language, this method
|
|
* will try to autoselect a master language which is shown alongside
|
|
* the normal formfields as a readonly representation.
|
|
* This gives translators a powerful tool for their translation workflow
|
|
* without leaving the translated page interface.
|
|
* Translatable also adds a new tab "Translation" which shows existing
|
|
* translations, as well as a formaction to create new translations based
|
|
* on a dropdown with available languages.
|
|
*
|
|
* @todo This is specific to SiteTree and CMSMain
|
|
* @todo Implement a special "translation mode" which triggers display of the
|
|
* readonly fields, so you can translation INTO the "default language" while
|
|
* seeing readonly fields as well.
|
|
*/
|
|
function updateCMSFields(FieldSet &$fields) {
|
|
if(!class_exists('SiteTree')) return;
|
|
// Don't apply these modifications for normal DataObjects - they rely on CMSMain logic
|
|
if(!($this->owner instanceof SiteTree)) return;
|
|
|
|
// used in CMSMain->init() to set language state when reading/writing record
|
|
$fields->push(new HiddenField("Locale", "Locale", $this->owner->Locale) );
|
|
|
|
// Don't allow translation of virtual pages because of data inconsistencies (see #5000)
|
|
if(class_exists('VirtualPage')){
|
|
$excludedPageTypes = array('VirtualPage');
|
|
foreach($excludedPageTypes as $excludedPageType) {
|
|
if(is_a($this->owner, $excludedPageType)) return;
|
|
}
|
|
}
|
|
|
|
$excludeFields = array(
|
|
'ViewerGroups',
|
|
'EditorGroups',
|
|
'CanViewType',
|
|
'CanEditType'
|
|
);
|
|
|
|
// if a language other than default language is used, we're in "translation mode",
|
|
// hence have to modify the original fields
|
|
$creating = false;
|
|
$baseClass = $this->owner->class;
|
|
$allFields = $fields->toArray();
|
|
while( ($p = get_parent_class($baseClass)) != "DataObject") $baseClass = $p;
|
|
|
|
// try to get the record in "default language"
|
|
$originalRecord = $this->owner->getTranslation(Translatable::default_locale());
|
|
// if no translation in "default language", fall back to first translation
|
|
if(!$originalRecord) {
|
|
$translations = $this->owner->getTranslations();
|
|
$originalRecord = ($translations) ? $translations->First() : null;
|
|
}
|
|
|
|
$isTranslationMode = $this->owner->Locale != Translatable::default_locale();
|
|
|
|
// Show a dropdown to create a new translation.
|
|
// This action is possible both when showing the "default language"
|
|
// and a translation. Include the current locale (record might not be saved yet).
|
|
$alreadyTranslatedLocales = $this->getTranslatedLocales();
|
|
$alreadyTranslatedLocales[$this->owner->Locale] = $this->owner->Locale;
|
|
|
|
if($originalRecord && $isTranslationMode) {
|
|
$originalLangID = Session::get($this->owner->ID . '_originalLangID');
|
|
|
|
// Remove parent page dropdown
|
|
$fields->removeByName("ParentType");
|
|
$fields->removeByName("ParentID");
|
|
|
|
$translatableFieldNames = $this->getTranslatableFields();
|
|
$allDataFields = $fields->dataFields();
|
|
|
|
$transformation = new Translatable_Transformation($originalRecord);
|
|
|
|
// iterate through sequential list of all datafields in fieldset
|
|
// (fields are object references, so we can replace them with the translatable CompositeField)
|
|
foreach($allDataFields as $dataField) {
|
|
if($dataField instanceof HiddenField) continue;
|
|
if(in_array($dataField->Name(), $excludeFields)) continue;
|
|
|
|
if(in_array($dataField->Name(), $translatableFieldNames)) {
|
|
// if the field is translatable, perform transformation
|
|
$fields->replaceField($dataField->Name(), $transformation->transformFormField($dataField));
|
|
} else {
|
|
// else field shouldn't be editable in translation-mode, make readonly
|
|
$fields->replaceField($dataField->Name(), $dataField->performReadonlyTransformation());
|
|
}
|
|
}
|
|
|
|
} elseif($this->owner->isNew()) {
|
|
$fields->addFieldsToTab(
|
|
'Root',
|
|
new Tab(_t('Translatable.TRANSLATIONS', 'Translations'),
|
|
new LiteralField('SaveBeforeCreatingTranslationNote',
|
|
sprintf('<p class="message">%s</p>',
|
|
_t('Translatable.NOTICENEWPAGE', 'Please save this page before creating a translation')
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
$fields->addFieldsToTab(
|
|
'Root',
|
|
new Tab('Translations', _t('Translatable.TRANSLATIONS', 'Translations'),
|
|
new HeaderField('CreateTransHeader', _t('Translatable.CREATE', 'Create new translation'), 2),
|
|
$langDropdown = new LanguageDropdownField(
|
|
"NewTransLang",
|
|
_t('Translatable.NEWLANGUAGE', 'New language'),
|
|
$alreadyTranslatedLocales,
|
|
'SiteTree',
|
|
'Locale-English',
|
|
$this->owner
|
|
),
|
|
$createButton = new InlineFormAction('createtranslation',_t('Translatable.CREATEBUTTON', 'Create'))
|
|
)
|
|
);
|
|
$createButton->includeDefaultJS(false);
|
|
|
|
if($alreadyTranslatedLocales) {
|
|
$fields->addFieldToTab(
|
|
'Root.Translations',
|
|
new HeaderField('ExistingTransHeader', _t('Translatable.EXISTING', 'Existing translations:'), 3)
|
|
);
|
|
$existingTransHTML = '<ul>';
|
|
foreach($alreadyTranslatedLocales as $i => $langCode) {
|
|
$existingTranslation = $this->owner->getTranslation($langCode);
|
|
if($existingTranslation) {
|
|
$existingTransHTML .= sprintf('<li><a href="%s">%s</a></li>',
|
|
sprintf('admin/show/%d/?locale=%s', $existingTranslation->ID, $langCode),
|
|
i18n::get_locale_name($langCode)
|
|
);
|
|
}
|
|
}
|
|
$existingTransHTML .= '</ul>';
|
|
$fields->addFieldToTab(
|
|
'Root.Translations',
|
|
new LiteralField('existingtrans',$existingTransHTML)
|
|
);
|
|
}
|
|
|
|
$langDropdown->addExtraClass('languageDropdown');
|
|
$createButton->addExtraClass('createTranslationButton');
|
|
}
|
|
|
|
/**
|
|
* Get the names of all translatable fields on this class
|
|
* as a numeric array.
|
|
* @todo Integrate with blacklist once branches/translatable is merged back.
|
|
*
|
|
* @return array
|
|
*/
|
|
function getTranslatableFields() {
|
|
return $this->translatableFields;
|
|
}
|
|
|
|
/**
|
|
* Return the base table - the class that directly extends DataObject.
|
|
* @return string
|
|
*/
|
|
function baseTable($stage = null) {
|
|
$tableClasses = ClassInfo::dataClassesFor($this->owner->class);
|
|
$baseClass = array_shift($tableClasses);
|
|
return (!$stage || $stage == $this->defaultStage) ? $baseClass : $baseClass . "_$stage";
|
|
}
|
|
|
|
function extendWithSuffix($table) {
|
|
return $table;
|
|
}
|
|
|
|
/**
|
|
* Gets all related translations for the current object,
|
|
* excluding itself. See {@link getTranslation()} to retrieve
|
|
* a single translated object.
|
|
*
|
|
* Getter with $stage parameter is specific to {@link Versioned} extension,
|
|
* mostly used for {@link SiteTree} subclasses.
|
|
*
|
|
* @param string $locale
|
|
* @param string $stage
|
|
* @return DataObjectSet
|
|
*/
|
|
function getTranslations($locale = null, $stage = null) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
if($this->owner->exists()) {
|
|
// HACK need to disable language filtering in augmentSQL(),
|
|
// as we purposely want to get different language
|
|
self::disable_locale_filter();
|
|
|
|
$translationGroupID = $this->getTranslationGroup();
|
|
|
|
$baseDataClass = ClassInfo::baseDataClass($this->owner->class);
|
|
$filter = sprintf('"%s_translationgroups"."TranslationGroupID" = %d', $baseDataClass, $translationGroupID);
|
|
if($locale) {
|
|
$filter .= sprintf(' AND "%s"."Locale" = \'%s\'', $baseDataClass, Convert::raw2sql($locale));
|
|
} else {
|
|
// exclude the language of the current owner
|
|
$filter .= sprintf(' AND "%s"."Locale" != \'%s\'', $baseDataClass, $this->owner->Locale);
|
|
}
|
|
$join = sprintf('LEFT JOIN "%s_translationgroups" ON "%s_translationgroups"."OriginalID" = "%s"."ID"',
|
|
$baseDataClass,
|
|
$baseDataClass,
|
|
$baseDataClass
|
|
);
|
|
$currentStage = Versioned::current_stage();
|
|
if($this->owner->hasExtension("Versioned")) {
|
|
if($stage) Versioned::reading_stage($stage);
|
|
$translations = Versioned::get_by_stage(
|
|
$this->owner->class,
|
|
Versioned::current_stage(),
|
|
$filter,
|
|
null,
|
|
$join
|
|
);
|
|
if($stage) Versioned::reading_stage($currentStage);
|
|
} else {
|
|
$translations = DataObject::get($this->owner->class, $filter, null, $join);
|
|
}
|
|
|
|
self::enable_locale_filter();
|
|
|
|
return $translations;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an existing translation based on the language code.
|
|
* Use {@link hasTranslation()} as a quicker alternative to check
|
|
* for an existing translation without getting the actual object.
|
|
*
|
|
* @param String $locale
|
|
* @return DataObject Translated object
|
|
*/
|
|
function getTranslation($locale, $stage = null) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
$translations = $this->getTranslations($locale, $stage);
|
|
return ($translations) ? $translations->First() : null;
|
|
}
|
|
|
|
/**
|
|
* Creates a new translation for the owner object of this decorator.
|
|
* Checks {@link getTranslation()} to return an existing translation
|
|
* instead of creating a duplicate. Writes the record to the database before
|
|
* returning it. Use this method if you want the "translation group"
|
|
* mechanism to work, meaning that an object knows which group of translations
|
|
* it belongs to. For "original records" which are not created through this
|
|
* method, the "translation group" is set in {@link onAfterWrite()}.
|
|
*
|
|
* @param string $locale
|
|
* @return DataObject The translated object
|
|
*/
|
|
function createTranslation($locale) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
if(!$this->owner->exists()) {
|
|
user_error('Translatable::createTranslation(): Please save your record before creating a translation', E_USER_ERROR);
|
|
}
|
|
|
|
// permission check
|
|
if(!$this->owner->canTranslate(null, $locale)) {
|
|
throw new Exception(sprintf(
|
|
'Creating a new translation in locale "%s" is not allowed for this user',
|
|
$locale
|
|
));
|
|
return;
|
|
}
|
|
|
|
$existingTranslation = $this->getTranslation($locale);
|
|
if($existingTranslation) return $existingTranslation;
|
|
|
|
$class = $this->owner->class;
|
|
$newTranslation = new $class;
|
|
|
|
// copy all fields from owner (apart from ID)
|
|
$newTranslation->update($this->owner->toMap());
|
|
|
|
// If the object has Hierarchy extension,
|
|
// check for existing translated parents and assign
|
|
// their ParentID (and overwrite any existing ParentID relations
|
|
// to parents in other language). If no parent translations exist,
|
|
// they are automatically created in onBeforeWrite()
|
|
if($newTranslation->hasField('ParentID')) {
|
|
$origParent = $this->owner->Parent();
|
|
$newTranslationParent = $origParent->getTranslation($locale);
|
|
if($newTranslationParent) $newTranslation->ParentID = $newTranslationParent->ID;
|
|
}
|
|
|
|
$newTranslation->ID = 0;
|
|
$newTranslation->Locale = $locale;
|
|
|
|
$originalPage = $this->getTranslation(self::default_locale());
|
|
if ($originalPage) {
|
|
$urlSegment = $originalPage->URLSegment;
|
|
} else {
|
|
$urlSegment = $newTranslation->URLSegment;
|
|
}
|
|
$newTranslation->URLSegment = $urlSegment . '-' . i18n::convert_rfc1766($locale);
|
|
// hacky way to set an existing translation group in onAfterWrite()
|
|
$translationGroupID = $this->getTranslationGroup();
|
|
$newTranslation->_TranslationGroupID = $translationGroupID ? $translationGroupID : $this->owner->ID;
|
|
$newTranslation->write();
|
|
|
|
return $newTranslation;
|
|
}
|
|
|
|
/**
|
|
* Caution: Does not consider the {@link canEdit()} permissions.
|
|
*
|
|
* @param DataObject|int $member
|
|
* @param string $locale
|
|
* @return boolean
|
|
*/
|
|
function canTranslate($member = null, $locale) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
if(!$member || !(is_a($member, 'Member')) || is_numeric($member)) $member = Member::currentUser();
|
|
|
|
// check for locale
|
|
$allowedLocale = (
|
|
!is_array(self::get_allowed_locales())
|
|
|| in_array($locale, self::get_allowed_locales())
|
|
);
|
|
|
|
if(!$allowedLocale) return false;
|
|
|
|
// By default, anyone who can edit a page can edit the default locale
|
|
if($locale == self::default_locale()) return true;
|
|
|
|
// check for generic translation permission
|
|
if(Permission::checkMember($member, 'TRANSLATE_ALL')) return true;
|
|
|
|
// check for locale specific translate permission
|
|
if(!Permission::checkMember($member, 'TRANSLATE_' . $locale)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return boolean
|
|
*/
|
|
function canEdit($member) {
|
|
if(!$this->owner->Locale) return null;
|
|
return $this->owner->canTranslate($member, $this->owner->Locale) ? null : false;
|
|
}
|
|
|
|
/**
|
|
* Returns TRUE if the current record has a translation in this language.
|
|
* Use {@link getTranslation()} to get the actual translated record from
|
|
* the database.
|
|
*
|
|
* @param string $locale
|
|
* @return boolean
|
|
*/
|
|
function hasTranslation($locale) {
|
|
if($locale && !i18n::validate_locale($locale)) throw new InvalidArgumentException(sprintf('Invalid locale "%s"', $locale));
|
|
|
|
return (
|
|
$this->owner->Locale == $locale
|
|
|| array_search($locale, $this->getTranslatedLocales()) !== false
|
|
);
|
|
}
|
|
|
|
function AllChildrenIncludingDeleted($context = null) {
|
|
$children = $this->owner->doAllChildrenIncludingDeleted($context);
|
|
|
|
return $children;
|
|
}
|
|
|
|
/**
|
|
* Returns <link rel="alternate"> markup for insertion into
|
|
* a HTML4/XHTML compliant <head> section, listing all available translations
|
|
* of a page.
|
|
*
|
|
* @see http://www.w3.org/TR/html4/struct/links.html#edef-LINK
|
|
* @see http://www.w3.org/International/articles/language-tags/
|
|
*
|
|
* @return string HTML
|
|
*/
|
|
function MetaTags(&$tags) {
|
|
$template = '<link rel="alternate" type="text/html" title="%s" hreflang="%s" href="%s" />' . "\n";
|
|
$translations = $this->owner->getTranslations();
|
|
if($translations) foreach($translations as $translation) {
|
|
$tags .= sprintf($template,
|
|
Convert::raw2xml($translation->Title),
|
|
i18n::convert_rfc1766($translation->Locale),
|
|
$translation->Link()
|
|
);
|
|
}
|
|
}
|
|
|
|
function providePermissions() {
|
|
if(!Object::has_extension('SiteTree', 'Translatable') || !class_exists('SiteTree')) return false;
|
|
|
|
$locales = self::get_allowed_locales();
|
|
|
|
// Fall back to any locales used in existing translations (see #4939)
|
|
if(!$locales) {
|
|
$locales = DB::query('SELECT "Locale" FROM "SiteTree" GROUP BY "Locale"')->column();
|
|
}
|
|
|
|
$permissions = array();
|
|
if($locales) foreach($locales as $locale) {
|
|
$localeName = i18n::get_locale_name($locale);
|
|
$permissions['TRANSLATE_' . $locale] = sprintf(
|
|
_t(
|
|
'Translatable.TRANSLATEPERMISSION',
|
|
'Translate %s',
|
|
PR_MEDIUM,
|
|
'Translate pages into a language'
|
|
),
|
|
$localeName
|
|
);
|
|
}
|
|
|
|
$permissions['TRANSLATE_ALL'] = _t(
|
|
'Translatable.TRANSLATEALLPERMISSION',
|
|
'Translate into all available languages'
|
|
);
|
|
|
|
return $permissions;
|
|
}
|
|
|
|
/**
|
|
* Get a list of languages with at least one element translated in (including the default language)
|
|
*
|
|
* @param string $className Look for languages in elements of this class
|
|
* @param string $where Optional SQL WHERE statement
|
|
* @return array Map of languages in the form locale => langName
|
|
*/
|
|
static function get_existing_content_languages($className = 'SiteTree', $where = '') {
|
|
$baseTable = ClassInfo::baseDataClass($className);
|
|
$query = new SQLQuery("Distinct \"Locale\"","\"$baseTable\"",$where, '', "\"Locale\"");
|
|
$dbLangs = $query->execute()->column();
|
|
$langlist = array_merge((array)Translatable::default_locale(), (array)$dbLangs);
|
|
$returnMap = array();
|
|
$allCodes = array_merge(i18n::$all_locales, i18n::$common_locales);
|
|
foreach ($langlist as $langCode) {
|
|
if($langCode && isset($allCodes[$langCode])) {
|
|
$returnMap[$langCode] = (is_array($allCodes[$langCode])) ? $allCodes[$langCode][0] : $allCodes[$langCode];
|
|
}
|
|
}
|
|
return $returnMap;
|
|
}
|
|
|
|
|
|
/**
|
|
* @deprecated 2.4 Use {@link Translatable::get_homepage_link_by_locale()}
|
|
*/
|
|
static function get_homepage_urlsegment_by_locale($locale) {
|
|
user_error (
|
|
'Translatable::get_homepage_urlsegment_by_locale() is deprecated, please use get_homepage_link_by_locale()',
|
|
E_USER_NOTICE
|
|
);
|
|
|
|
return self::get_homepage_link_by_locale($locale);
|
|
}
|
|
|
|
/**
|
|
* Define all locales which in which a new translation is allowed.
|
|
* Checked in {@link canTranslate()}.
|
|
*
|
|
* @param array List of allowed locale codes (see {@link i18n::$all_locales}).
|
|
* Example: array('de_DE','ja_JP')
|
|
*/
|
|
static function set_allowed_locales($locales) {
|
|
self::$allowed_locales = $locales;
|
|
}
|
|
|
|
/**
|
|
* Get all locales which are generally permitted to be translated.
|
|
* Use {@link canTranslate()} to check if a specific member has permission
|
|
* to translate a record.
|
|
*
|
|
* @return array
|
|
*/
|
|
static function get_allowed_locales() {
|
|
return self::$allowed_locales;
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use get_homepage_urlsegment_by_locale()
|
|
*/
|
|
static function get_homepage_urlsegment_by_language($locale) {
|
|
return self::get_homepage_urlsegment_by_locale($locale);
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use custom check: self::$default_locale == self::get_current_locale()
|
|
*/
|
|
static function is_default_lang() {
|
|
return (self::$default_locale == self::get_current_locale());
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use set_default_locale()
|
|
*/
|
|
static function set_default_lang($lang) {
|
|
self::set_default_locale(i18n::get_locale_from_lang($lang));
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use get_default_locale()
|
|
*/
|
|
static function get_default_lang() {
|
|
return i18n::get_lang_from_locale(self::default_locale());
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use get_current_locale()
|
|
*/
|
|
static function current_lang() {
|
|
return i18n::get_lang_from_locale(self::get_current_locale());
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use set_current_locale()
|
|
*/
|
|
static function set_reading_lang($lang) {
|
|
self::set_current_locale(i18n::get_locale_from_lang($lang));
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use get_reading_locale()
|
|
*/
|
|
static function get_reading_lang() {
|
|
return i18n::get_lang_from_locale(self::get_reading_locale());
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use default_locale()
|
|
*/
|
|
static function default_lang() {
|
|
return i18n::get_lang_from_locale(self::default_locale());
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use get_by_locale()
|
|
*/
|
|
static function get_by_lang($class, $lang, $filter = '', $sort = '', $join = "", $limit = "", $containerClass = "DataObjectSet", $having = "") {
|
|
return self::get_by_locale($class, i18n::get_locale_from_lang($lang), $filter, $sort, $join, $limit, $containerClass, $having);
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use get_one_by_locale()
|
|
*/
|
|
static function get_one_by_lang($class, $lang, $filter = '', $cache = false, $orderby = "") {
|
|
return self::get_one_by_locale($class, i18n::get_locale_from_lang($lang), $filter, $cache, $orderby);
|
|
}
|
|
|
|
/**
|
|
* Determines if the record has a locale,
|
|
* and if this locale is different from the "default locale"
|
|
* set in {@link Translatable::default_locale()}.
|
|
* Does not look at translation groups to see if the record
|
|
* is based on another record.
|
|
*
|
|
* @return boolean
|
|
* @deprecated 2.4
|
|
*/
|
|
function isTranslation() {
|
|
return ($this->owner->Locale && ($this->owner->Locale != Translatable::default_locale()));
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use choose_site_locale()
|
|
*/
|
|
static function choose_site_lang($langsAvail=null) {
|
|
return self::choose_site_locale($langsAvail);
|
|
}
|
|
|
|
/**
|
|
* @deprecated 2.4 Use getTranslatedLocales()
|
|
*/
|
|
function getTranslatedLangs() {
|
|
return $this->getTranslatedLocales();
|
|
}
|
|
|
|
/**
|
|
* Return a piece of text to keep DataObject cache keys appropriately specific
|
|
*/
|
|
function cacheKeyComponent() {
|
|
return 'locale-'.self::get_current_locale();
|
|
}
|
|
|
|
/**
|
|
* Extends the SiteTree::validURLSegment() method, to do checks appropriate
|
|
* to Translatable
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function augmentValidURLSegment() {
|
|
if (self::locale_filter_enabled()) {
|
|
self::disable_locale_filter();
|
|
$reEnableFilter = true;
|
|
}
|
|
$IDFilter = ($this->owner->ID) ? "AND \"SiteTree\".\"ID\" <> {$this->owner->ID}" : null;
|
|
$parentFilter = null;
|
|
|
|
if(SiteTree::nested_urls()) {
|
|
if($this->owner->ParentID) {
|
|
$parentFilter = " AND \"SiteTree\".\"ParentID\" = {$this->owner->ParentID}";
|
|
} else {
|
|
$parentFilter = ' AND "SiteTree"."ParentID" = 0';
|
|
}
|
|
}
|
|
|
|
$existingPage = DataObject::get_one(
|
|
'SiteTree',
|
|
"\"URLSegment\" = '{$this->owner->URLSegment}' $IDFilter $parentFilter",
|
|
false // disable get_one cache, as this otherwise may pick up results from when locale_filter was on
|
|
);
|
|
if ($reEnableFilter) {
|
|
self::enable_locale_filter();
|
|
}
|
|
return !$existingPage;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Transform a formfield to a "translatable" representation,
|
|
* consisting of the original formfield plus a readonly-version
|
|
* of the original value, wrapped in a CompositeField.
|
|
*
|
|
* @param DataObject $original Needs the original record as we populate the readonly formfield with the original value
|
|
*
|
|
* @package sapphire
|
|
* @subpackage misc
|
|
*/
|
|
class Translatable_Transformation extends FormTransformation {
|
|
|
|
/**
|
|
* @var DataObject
|
|
*/
|
|
private $original = null;
|
|
|
|
function __construct(DataObject $original) {
|
|
$this->original = $original;
|
|
parent::__construct();
|
|
}
|
|
|
|
/**
|
|
* Returns the original DataObject attached to the Transformation
|
|
*
|
|
* @return DataObject
|
|
*/
|
|
function getOriginal() {
|
|
return $this->original;
|
|
}
|
|
|
|
/**
|
|
* @todo transformTextareaField() not used at the moment
|
|
*/
|
|
function transformTextareaField(TextareaField $field) {
|
|
$nonEditableField = new ToggleField($fieldname,$field->Title(),'','+','-');
|
|
$nonEditableField->labelMore = '+';
|
|
$nonEditableField->labelLess = '-';
|
|
return $this->baseTransform($nonEditableField, $field);
|
|
|
|
return $nonEditableField;
|
|
}
|
|
|
|
function transformFormField(FormField $field) {
|
|
$newfield = $field->performReadOnlyTransformation();
|
|
return $this->baseTransform($newfield, $field);
|
|
}
|
|
|
|
protected function baseTransform($nonEditableField, $originalField) {
|
|
$fieldname = $originalField->Name();
|
|
|
|
$nonEditableField_holder = new CompositeField($nonEditableField);
|
|
$nonEditableField_holder->setName($fieldname.'_holder');
|
|
$nonEditableField_holder->addExtraClass('originallang_holder');
|
|
$nonEditableField->setValue($this->original->$fieldname);
|
|
$nonEditableField->setName($fieldname.'_original');
|
|
$nonEditableField->addExtraClass('originallang');
|
|
$nonEditableField->setTitle('Original '.$originalField->Title());
|
|
|
|
$nonEditableField_holder->insertBefore($originalField, $fieldname.'_original');
|
|
return $nonEditableField_holder;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
?>
|