/**
* Execute the task
*
* @param array $taskData Task data
*
* @return bool True on success, false otherwise
*/
public function run($taskData)
{
if (!empty($taskData['tableId'])) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($taskData['tableId']);
if (!empty($table)) {
$table->applyFiltersToExistingContent();
}
}
}
/**
* Generate content element file
*
* @return void
*/
public function downloadContentElementFile()
{
$input = JFactory::getApplication()->input;
$tableId = $input->getInt('table_id');
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($tableId, false, true);
/* @var $tableObject stdClass */
$tableObject = $table->prepareDataForView();
// Make file name
$tableName = str_replace('#__', '', $tableObject->table_name);
$fileName = $tableName . '_contentelements.xml';
$displayData = array();
$displayData['table_name'] = $tableName;
$displayData['table'] = $tableObject;
// Output XML
header('Content-Type: application/xml; charset=utf-8');
header('Content-Disposition: attachment; filename="' . $fileName . '"');
echo JLayoutHelper::render('contentelementxml', $displayData, JPATH_NENO_LAYOUTS);
JFactory::getApplication()->close();
}
/**
* Generate content element file
*
* @return void
*/
public function downloadContentElementFile()
{
$input = JFactory::getApplication()->input;
$tableId = $input->getInt('table_id');
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($tableId, false, true);
/* @var $tableObject stdClass */
$tableObject = $table->prepareDataForView();
// Make file name
$tableName = str_replace('#__', '', $tableObject->table_name);
$fileName = $tableName . '_contentelements.xml';
$displayData = array();
$displayData['table_name'] = $tableName;
$displayData['table'] = $tableObject;
// Output XML
header('Content-Type: application/xml; charset=utf-8');
header('Content-Disposition: attachment; filename="' . $fileName . '"');
// Creating XML file (the right way to do it!)
$nenoXml = new SimpleXMLElement('<neno />');
$nenoXml->addAttribute('type', 'contentelement');
$nenoXml->addChild('name', $tableName);
$nenoXml->addChild('author', 'Neno - http://www.neno-translate.com');
$nenoXml->addChild('version', '1.0.0');
$nenoXml->addChild('description', 'Definition of the table ' . $tableName);
$nenoXml->addChild('translate', $tableObject->translate);
$reference = $nenoXml->addChild('reference');
$reference->addAttribute('type', 'content');
$tableNode = $reference->addChild('table');
$tableNode->addAttribute('name', $tableName);
foreach ($tableObject->fields as $field) {
$fieldNode = $tableNode->addChild('field', $field->field_name);
$fieldNode->addAttribute('type', in_array($field->field_name, $displayData['table']->primary_key) ? 'referenceid' : 'text');
$fieldNode->addAttribute('name', $field->field_name);
$fieldNode->addAttribute('translate', $field->translate);
}
echo $nenoXml->asXML();
JFactory::getApplication()->close();
}
/**
* Grouping tables that haven't been discovered
*
* @param bool $persist Persist the group
*
* @return NenoContentElementGroup
*/
public static function groupingTablesNotDiscovered($persist = true)
{
/* @var $db NenoDatabaseDriverMysqlx */
$db = JFactory::getDbo();
// Get all the tables that haven't been detected using naming convention.
$tablesNotDiscovered = self::getTablesNotDiscovered();
$tablesAdded = false;
$otherGroup = null;
if (!empty($tablesNotDiscovered)) {
// Check if this group exists already
$query = $db->getQuery(true);
$query->select('g.id')->from('#__neno_content_element_groups AS g')->where('NOT EXISTS (SELECT 1 FROM #__neno_content_element_groups_x_extensions AS ge WHERE ge.group_id = g.id)');
$db->setQuery($query);
$groupId = $db->loadResult();
if (!empty($groupId)) {
/* @var $otherGroup NenoContentElementGroup */
$otherGroup = NenoContentElementGroup::load($groupId);
} else {
$otherGroup = new NenoContentElementGroup(array('group_name' => 'Other'));
}
$tablesIgnored = NenoHelper::getDoNotTranslateTables();
foreach ($tablesNotDiscovered as $tableNotDiscovered) {
if (!in_array($tableNotDiscovered, $tablesIgnored)) {
// Create an array with the table information
$tableData = array('tableName' => $tableNotDiscovered, 'primaryKey' => $db->getPrimaryKey($tableNotDiscovered), 'translate' => 1, 'group' => $otherGroup);
// Create ContentElement object
$table = new NenoContentElementTable($tableData);
// Get all the columns a table contains
$fields = $db->getTableColumns($table->getTableName());
foreach ($fields as $fieldName => $fieldType) {
$fieldData = array('fieldName' => $fieldName, 'fieldType' => $fieldType, 'translate' => NenoContentElementField::isTranslatableType($fieldType), 'table' => $table);
$field = new NenoContentElementField($fieldData);
$table->addField($field);
}
$otherGroup->addTable($table);
$tablesAdded = true;
}
}
$otherGroup->setAssignedTranslationMethods(NenoHelper::getTranslationMethodsForLanguages());
if ($persist) {
$otherGroup->persist();
}
}
if (!$tablesAdded) {
$otherGroup = null;
}
return $otherGroup;
}
public function checkIntegrity()
{
$input = $this->input;
// Refresh content for groups
$groups = $input->get('groups', array(), 'ARRAY');
$tables = $input->get('tables', array(), 'ARRAY');
$workingLanguage = NenoHelper::getWorkingLanguage();
if (!empty($groups)) {
foreach ($groups as $groupId) {
$tables = NenoContentElementTable::load(array('group_id' => $groupId, 'translate' => 1));
// Making sure the result is an array
if (!is_array($tables)) {
$tables = array($tables);
}
/* @var $table NenoContentElementTable */
foreach ($tables as $table) {
// Check table integrity
$table->checkIntegrity($workingLanguage);
}
}
} elseif (!empty($tables)) {
foreach ($tables as $tableId) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($tableId);
if (!empty($table) && $table->isTranslate()) {
// Check table integrity
$table->checkIntegrity($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();
}
/**
* Check if a table has been already discovered.
*
* @param string $tableName Table name
*
* @return bool
*/
public static function isTableAlreadyDiscovered($tableName)
{
$db = JFactory::getDbo();
$query = $db->getQuery(true);
$query->select('1')->from(NenoContentElementTable::getDbTable())->where('table_name LIKE ' . $db->quote(self::unifyTableName($tableName)));
$db->setQuery($query);
$result = $db->loadResult();
return $result == 1;
}
/**
* {@inheritdoc}
*
* @return bool|mixed
*/
public function execute()
{
$language = JFactory::getLanguage();
$app = JFactory::getApplication();
// Check if the user is trying to insert something in the front-end in different language
if ($this->getQueryType((string) $this->sql) === self::INSERT_QUERY && $language->getTag() !== NenoSettings::get('source_language') && $app->isSite() && !$this->isNenoSql((string) $this->sql)) {
$tables = null;
preg_match('/insert into (\\w+)/', $this->sql, $tables);
if (!empty($tables)) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load(array('table_name' => $tables[1]));
if (!empty($table) && $table->isTranslate()) {
$language->load('com_neno', JPATH_ADMINISTRATOR);
throw new Exception(JText::_('COM_NENO_CONTENT_IN_OTHER_LANGUAGES_ARE_NOT_ALLOWED'));
}
}
} else {
try {
// Get query type
$queryType = $this->getQueryType((string) $this->sql);
$result = parent::execute();
// If the query is creating/modifying/deleting a record, let's do the same on the shadow tables
if (($queryType === self::INSERT_QUERY || $queryType === self::DELETE_QUERY || $queryType === self::UPDATE_QUERY || $queryType === self::REPLACE_QUERY) && $this->hasToBeParsed((string) $this->sql)) {
$sql = $this->sql;
foreach ($this->languages as $language) {
$newSql = $this->replaceTableNameStatements((string) $sql, $language->lang_code);
// Execute query if they are different.
if ($newSql != $sql) {
$this->executeQuery($newSql, false);
}
}
}
return $result;
} catch (RuntimeException $ex) {
NenoLog::log($ex->getMessage(), NenoLog::PRIORITY_ERROR);
}
}
return false;
}
/**
* @throws Exception
*
* @return void
*/
public function refreshRecordCounter()
{
$app = JFactory::getApplication();
$input = $app->input;
$tableId = $input->getInt('tableId');
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($tableId);
echo $table->recordCount, $app->close();
}
/**
* Process a file
*
* @return bool True on success, false otherwise
*/
public function processJobFinished()
{
$config = JFactory::getConfig();
$tmpPath = $config->get('tmp_path');
$filename = $this->getFileName();
$fileContents = json_decode(file_get_contents($tmpPath . '/' . $filename . '.json' . '/' . $filename . '.json'), true);
if ($fileContents !== null) {
foreach ($fileContents['strings'] as $translationId => $translationText) {
/* @var $translation NenoContentElementTranslation */
$translation = NenoContentElementTranslation::load($translationId, false, true);
if (!empty($translation)) {
$translation->setString(NenoHelper::replaceTranslationsInHtmlTag($translation->getOriginalText(), html_entity_decode($translationText, ENT_COMPAT | ENT_HTML401, $this->getCorrectEncodingCharset($this->getToLanguage()))));
// Mark this translation method as completed
$translation->markTranslationMethodAsCompleted($this->translationMethod->id);
if ($translation->isBeingCompleted()) {
$translation->setState(NenoContentElementTranslation::TRANSLATED_STATE);
}
// Saving translation
if ($translation->persist()) {
// Move translation to the target even if it's not completed. Machine => Professional || Professional => Manual
$translation->moveTranslationToTarget();
}
}
}
// Ensure the shadow tables of the target language have their language column (if there's any) properly set.
$tables = NenoContentElementTable::load(array('translate' => 1));
/* @var $table NenoContentElementTable */
foreach ($tables as $table) {
$table->checkIntegrity($this->getToLanguage());
}
return true;
}
return false;
}
/**
* Get a ContentElementField related to a table and field name
*
* @param NenoContentElementTable $table Table
* @param string $fieldName Field name
*
* @return NenoContentElementField
*/
public static function getFieldByTableAndFieldName(NenoContentElementTable $table, $fieldName)
{
// Get fields related to this table
$fields = $table->getFields(false);
$field = null;
if (!empty($fields)) {
$fields = $table->getFields(false);
$found = false;
for ($i = 0; $i < count($fields) && !$found; $i++) {
/* @var $field NenoContentElementField */
$field = $fields[$i];
if ($field->getFieldName() == $fieldName) {
$found = true;
}
}
if ($found) {
if ($field->getId() == null) {
$field = self::getFieldDataFromDatabase($table->getId(), $fieldName);
}
return $field;
}
return false;
} else {
return self::getFieldDataFromDatabase($table->getId(), $fieldName);
}
}
public function onCategoryChangeState($context, $pks, $value)
{
if ($value == -2) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load(array('table_name' => '#__categories'), false);
foreach ($pks as $pk) {
$this->trashTranslations($table, $pk);
}
}
}
/**
* Toggle translate status for tables
*
* @return void
*/
public function toggleContentElementTable()
{
NenoLog::log('Method toggleContentElementTable of NenoControllerGroupsElements called', 3);
$input = JFactory::getApplication()->input;
$tableId = $input->getInt('tableId');
$translateStatus = $input->getBool('translateStatus');
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::getTableById($tableId);
// If the table exists, let's work with it.
if ($table !== false) {
$table->setTranslate($translateStatus);
if ($table->persist() === false) {
NenoLog::log('Error saving new state!', NenoLog::PRIORITY_ERROR);
}
}
JFactory::getApplication()->close();
}
/**
* Sync group level hierarchy
*
* @return void
*/
public function sync()
{
/* @var $db NenoDatabaseDriverMysqlx */
$db = JFactory::getDbo();
$tables = $db->getNenoTableList();
foreach ($tables as $key => $table) {
$tables[$key] = str_replace($db->getPrefix(), '#__', $table);
}
$query = $db->getQuery(true);
$query->select('id')->from('#__neno_content_element_tables')->where(array('table_name NOT IN (' . implode(',', $db->quote($tables)) . ')', 'group_id = ' . (int) $this->id));
$db->setQuery($query);
$tableIds = $db->loadArray();
$reArrangeTables = false;
foreach ($tableIds as $tableId) {
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load($tableId);
if (!empty($table) && $table->remove()) {
/* @var $tableObject NenoContentElementTable */
foreach ($this->tables as $key => $tableObject) {
if ($tableObject->getId() == $tableId) {
$reArrangeTables = true;
unset($this->tables[$key]);
}
}
}
}
if ($reArrangeTables) {
$this->tables = array_values($this->tables);
}
}
/**
* Get all the tables related to this group
*
* @param bool $loadExtraData Calculate other data
* @param bool $loadTablesNotDiscovered Only loads tables that have not been discovered yet
* @param bool $avoidDoNotTranslate Don't load tables marked as Don't translate
*
* @return array
*/
public function getTables($loadExtraData = true, $loadTablesNotDiscovered = false, $avoidDoNotTranslate = false)
{
if ($this->tables === null || $loadTablesNotDiscovered) {
if ($loadTablesNotDiscovered) {
$this->tables = NenoHelper::getComponentTables($this, null, false);
} else {
$this->tables = NenoContentElementTable::load(array('group_id' => $this->getId()), $loadExtraData);
// If there's only one table
if ($this->tables instanceof NenoContentElementTable) {
$this->tables = array($this->tables);
}
/* @var $table NenoContentElementTable */
foreach ($this->tables as $key => $table) {
if ($avoidDoNotTranslate && !$this->tables[$key]->isTranslate()) {
unset($this->tables[$key]);
continue;
}
$this->tables[$key]->setGroup($this);
}
}
}
return $this->tables;
}
/**
* This event discover/sync tables
*
* @param string $tableName Table name
*
* @return void
*/
public function onDatabaseStructure($tableName)
{
$db = JFactory::getDbo();
// Unify table name
$tableName = str_replace($db->getPrefix(), '#__', $tableName);
/* @var $table NenoContentElementTable */
$table = NenoContentElementTable::load(array('table_name' => $tableName));
if (empty($table)) {
$otherGroup = NenoContentElementGroup::load(array('other_group' => 1));
$table = NenoHelper::createTableInstance($tableName, $otherGroup);
$table->persist();
} else {
$table->sync();
}
}
/**
* 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']));
}
$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, 'table_id' => NenoSettings::get('discovering_element_1.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, 'languagefile_id' => NenoSettings::get('discovering_element_1.2')), false, true);
} else {
$languageString = NenoContentElementLanguageString::load($elementId);
}
if (!empty($languageString)) {
$element = $languageString;
}
break;
}
return $element;
}
