/**
* Constructor
*
* @param mixed $data Language string data
* @param bool $loadExtraData If extra data should be loaded
* @param bool $loadParent If the parent should be loaded
*/
public function __construct($data, $loadExtraData = false, $loadParent = false)
{
parent::__construct($data);
$this->translations = null;
$data = (array) $data;
if ($this->isNew()) {
$this->timeAdded = new DateTime();
} else {
if (!$this->timeAdded instanceof DateTime) {
$this->timeAdded = new DateTime($this->timeAdded);
}
}
if ($loadParent) {
$this->languageFile = NenoContentElementLanguageFile::load($data['languagefileId'], $loadExtraData, $loadParent);
}
}
/**
* Get all the language files
*
* @return array
*/
public function getLanguageFiles()
{
if ($this->languageFiles === null) {
$this->languageFiles = NenoContentElementLanguageFile::load(array('group_id' => $this->getId()));
if (!is_array($this->languageFiles)) {
$this->languageFiles = array($this->languageFiles);
}
}
return $this->languageFiles;
}
public function scanForContent()
{
$input = $this->input;
// Refresh content for groups
$groups = $input->get('groups', array(), 'ARRAY');
$tables = $input->get('tables', array(), 'ARRAY');
$files = $input->get('files', array(), 'ARRAY');
$workingLanguage = NenoHelper::getWorkingLanguage();
if (!empty($groups)) {
foreach ($groups as $groupId) {
/* @var $group NenoContentElementGroup */
$group = NenoContentElementGroup::load($groupId);
if (!empty($group)) {
$group->refresh($workingLanguage);
}
}
} elseif (!empty($tables) || !empty($files)) {
foreach ($tables as $tableId) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($tableId);
if (!empty($table) && $table->isTranslate()) {
// Sync table
$table->sync();
$fields = $table->getFields(false, true);
if (!empty($fields)) {
/* @var $field NenoContentElementField */
foreach ($fields as $field) {
$field->persistTranslations(null, $workingLanguage);
}
}
}
}
foreach ($files as $fileId) {
/* @var $file NenoContentElementLanguageFile */
$file = NenoContentElementLanguageFile::load($fileId);
if (!empty($file)) {
$file->loadStringsFromFile();
$languageStrings = $file->getLanguageStrings();
if (!empty($languageStrings)) {
/* @var $languageString NenoContentElementLanguageString */
foreach ($languageStrings as $languageString) {
$languageString->persistTranslations($workingLanguage);
}
}
}
}
}
JFactory::getApplication()->redirect('index.php?option=com_neno&view=groupselements');
}
/**
* Move elements
*
* @return void
*/
public function move()
{
$input = JFactory::getApplication()->input;
$groupId = $input->getInt('group_id');
/* @var $group NenoContentElementGroup */
$group = NenoContentElementGroup::load($groupId);
$tables = $input->get('tables', array(), 'array');
$files = $input->get('files', array(), 'files');
$url = JRoute::_('index.php?option=com_neno&view=groupselements', false);
// Ensure that group_id was set
if (empty($groupId)) {
$this->setMessage(JText::_('COM_NENO_VIEW_MOVELEMENTCONFIRM_ERR_GROUP_REQUIRED'), 'error');
$this->setRedirect($url);
$this->redirect();
}
// Ensure that there is at least one table or file
if (empty($tables) && empty($files)) {
$this->setRedirect($url);
$this->redirect();
}
$msg = '';
// Move tables
if (count($tables) > 0) {
foreach ($tables as $table_id) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($table_id, true, true);
$table->setGroup($group);
$table->persist();
}
$msg .= JText::sprintf('COM_NENO_VIEW_MOVELEMENTCONFIRM_X_TABLES_MOVED', count($tables));
}
// Move files
if (count($files) > 0) {
foreach ($files as $file_id) {
/* @var $file NenoContentElementLanguageFile */
$file = NenoContentElementLanguageFile::load($file_id);
$file->setGroup($group);
$file->persist();
}
$msg .= JText::sprintf('COM_NENO_VIEW_MOVELEMENTCONFIRM_X_FILES_MOVED', count($files));
}
$this->setMessage($msg);
$this->setRedirect($url);
$this->redirect();
}
/**
* Get all the language strings related to a extension (group).
*
* @param string $extensionName Extension name
*
* @return array
*/
public static function getLanguageFiles($extensionName)
{
jimport('joomla.filesystem.folder');
$defaultLanguage = NenoSettings::get('source_language');
$languageFilePattern = preg_quote($defaultLanguage) . '\\.' . $extensionName . '\\.(((\\w)*\\.)^sys)?ini';
$languageFilesPath = JFolder::files(JPATH_ROOT . "/language/{$defaultLanguage}/", $languageFilePattern);
// Getting the template to check if there are files in the template
$template = self::getFrontendTemplate();
// If there is a template, let's try to get those files
if (!empty($template)) {
$templateLanguageFilesPath = JPATH_ROOT . "/templates/{$template}/language/{$defaultLanguage}/";
$overwriteFiles = false;
if (file_exists($templateLanguageFilesPath)) {
$overwriteFiles = JFolder::files(JPATH_ROOT . "/templates/{$template}/language/{$defaultLanguage}/", $languageFilePattern);
}
if ($overwriteFiles !== false) {
$languageFilesPath = array_merge($languageFilesPath, $overwriteFiles);
}
}
$languageFiles = array();
foreach ($languageFilesPath as $languageFilePath) {
// Only save the language strings if it's not a Joomla core components
if (!self::isJoomlaCoreLanguageFile($languageFilePath)) {
// Checking if the file is already discovered
if (self::isLanguageFileAlreadyDiscovered($languageFilePath)) {
$languageFile = NenoContentElementLanguageFile::load(array('filename' => $languageFilePath));
} else {
$languageFile = new NenoContentElementLanguageFile(array('filename' => $languageFilePath, 'extension' => $extensionName));
$languageFile->loadStringsFromFile();
}
if (!empty($languageFile)) {
$languageFiles[] = $languageFile;
}
}
}
return $languageFiles;
}
/**
* Get a particular element using the level
*
* @param string $level Hierarchy level
*
* @return NenoContentElementInterface|null
*/
protected function getElementByLevel($level)
{
$element = null;
$elementId = NenoSettings::get('discovering_element_' . $level);
$this->initPercents();
$db = JFactory::getDbo();
$query = $db->getQuery(true);
switch ($level) {
// Groups
case '0':
// This means to get a group that haven't been discovered yet
$extensions = $db->quote(NenoHelper::whichExtensionsShouldBeTranslated());
$query->clear()->select('e.*')->from('`#__extensions` AS e')->where(array('e.type IN (' . implode(',', $extensions) . ')', 'e.name NOT LIKE \'com_neno\'', 'NOT EXISTS (SELECT 1 FROM #__neno_content_element_groups_x_extensions AS ge WHERE ge.extension_id = e.extension_id)'))->order('name');
$db->setQuery($query, 0, 1);
$extension = $db->loadAssoc();
if (!empty($extension)) {
// Check if this extension has been discovered already
$groupId = NenoHelper::isExtensionAlreadyDiscovered($extension['extension_id']);
if ($groupId !== false) {
$group = NenoContentElementGroup::load($groupId);
} else {
$group = new NenoContentElementGroup(array('group_name' => $extension['name']));
}
/* @var $group NenoContentElementGroup */
$group->addExtension($extension['extension_id']);
$extensionName = NenoHelper::getExtensionName($extension);
$languageFiles = NenoHelper::getLanguageFiles($extensionName);
$tables = NenoHelper::getComponentTables($group, $extensionName);
$group->setAssignedTranslationMethods(NenoHelper::getTranslationMethodsForLanguages());
// If the group contains tables and/or language strings, let's save it
if (!empty($tables) || !empty($languageFiles)) {
$group->setLanguageFiles($languageFiles)->setTables($tables);
}
$element = $group;
} else {
$element = NenoHelperBackend::groupingTablesNotDiscovered(false);
}
break;
// Tables
// Tables
case '1.1':
// This means to get a table which has fields that haven't been discovered yet.
if (empty($elementId)) {
// Get one table that hasn't been discovered yet
$table = NenoContentElementTable::load(array('discovered' => 0, '_limit' => 1, 'translate' => 1, 'group_id' => NenoSettings::get('discovering_element_0')), false, true);
} else {
$table = NenoContentElementTable::load($elementId, false, true);
}
if (!empty($table)) {
$element = $table;
}
break;
// Language files
// Language files
case '1.2':
// This means to get a language file which has language strings that haven't been discovered yet.
if ($elementId == null) {
// Get one table that hasn't been discovered yet
$languageFile = NenoContentElementLanguageFile::load(array('discovered' => 0, '_limit' => 1, 'group_id' => NenoSettings::get('discovering_element_0')), false, true);
} else {
$languageFile = NenoContentElementLanguageFile::load($elementId, false, true);
}
if (!empty($languageFile)) {
$element = $languageFile;
}
break;
// Fields
// Fields
case '2.1':
// This means to get a field that hasn't been completed yet.
if ($elementId == null) {
// Get one table that hasn't been discovered yet
$field = NenoContentElementField::load(array('discovered' => 0, '_limit' => 1, 'translate' => 1), false, true);
} else {
$field = NenoContentElementField::load($elementId);
}
if (!empty($field) && $field) {
$element = $field;
}
break;
// Language strings
// Language strings
case '2.2':
// This means to get a language string that hasn't been completed yet.
if ($elementId == null) {
// Get one table that hasn't been discovered yet
$languageString = NenoContentElementLanguageString::load(array('discovered' => 0, '_limit' => 1), false, true);
} else {
$languageString = NenoContentElementLanguageString::load($elementId);
}
if (!empty($languageString)) {
$element = $languageString;
}
break;
}
return $element;
}
