public function __construct($name, $mountId, $startId, $notfoundId, array $clangs = null, $startClang = 1, $title = '', $description = '', $robots = '')
{
$this->name = $name;
$this->mountId = $mountId;
$this->startId = $startId;
$this->notfoundId = $notfoundId;
$this->clangs = is_null($clangs) ? rex_clang::getAllIds() : $clangs;
$this->startClang = $startClang;
$this->title = $title;
$this->description = $description;
$this->robots = $robots;
}
/**
* Löscht die gecachten Content-Dateien eines Artikels. Wenn keine clang angegeben, wird
* der Artikel in allen Sprachen gelöscht.
*
* @param int $id ArtikelId des Artikels
* @param int $clang ClangId des Artikels
*
* @return bool True on success, False on errro
*/
public static function deleteContent($id, $clang = null)
{
// sanity check
if ($id < 0) {
return false;
}
$cachePath = rex_path::addonCache('structure');
foreach (rex_clang::getAllIds() as $_clang) {
if ($clang !== null && $clang != $_clang) {
continue;
}
rex_file::delete($cachePath . $id . '.' . $_clang . '.content');
}
return true;
}
public function __construct($name, $scheme, $path, $mountId, $startId, $notfoundId, array $clangs = null, $startClang = 1, $title = '', $description = '', $robots = '')
{
$this->name = $name;
$this->path = $path;
$scheme = $scheme ?: (rex_yrewrite::isHttps() ? 'https' : 'http');
$this->url = $scheme . '://' . $name . $path;
$this->mountId = $mountId;
$this->startId = $startId;
$this->notfoundId = $notfoundId;
$this->clangs = is_null($clangs) ? rex_clang::getAllIds() : $clangs;
$this->startClang = $startClang;
$this->title = $title;
$this->description = $description;
$this->robots = $robots;
}
/**
* Speichert das Formular.
*
* Übernimmt die Werte aus den FormElementen in die Datenbank.
*
* Gibt true zurück wenn alles ok war, false bei einem allgemeinen Fehler,
* einen String mit einer Fehlermeldung oder den von der Datenbank gelieferten ErrorCode.
*
* @return bool
*/
protected function save()
{
$sql = rex_sql::factory();
$sql->setDebug($this->debug);
$sql->setTable($this->tableName);
$values = [];
foreach ($this->getSaveElements() as $fieldsetName => $fieldsetElements) {
foreach ($fieldsetElements as $element) {
// read-only-fields nicht speichern
if (strpos($element->getAttribute('class'), 'form-control-static') !== false) {
continue;
}
$fieldName = $element->getFieldName();
$fieldValue = $element->getSaveValue();
// Callback, um die Values vor dem Speichern noch beeinflussen zu können
$fieldValue = $this->preSave($fieldsetName, $fieldName, $fieldValue, $sql);
$values[$fieldName] = $fieldValue;
}
}
try {
if ($this->isEditMode()) {
$sql->setValues($values);
$sql->setWhere($this->whereCondition);
$sql->update();
} else {
if (count($this->languageSupport)) {
foreach (rex_clang::getAllIds() as $clang_id) {
$sql->setTable($this->tableName);
$sql->addGlobalCreateFields();
$sql->addGlobalUpdateFields();
if (!isset($id)) {
$id = $sql->setNewId($this->languageSupport['id']);
} else {
$sql->setValue($this->languageSupport['id'], $id);
}
$sql->setValue($this->languageSupport['clang'], $clang_id);
$sql->setValues($values);
$sql->insert();
}
} else {
$sql->setValues($values);
$sql->insert();
}
}
$saved = true;
} catch (rex_sql_exception $e) {
$saved = false;
}
// ----- EXTENSION POINT
if ($saved) {
$saved = rex_extension::registerPoint(new rex_extension_point('REX_FORM_SAVED', $saved, ['form' => $this, 'sql' => $sql]));
} else {
$saved = $sql->getErrno();
}
return $saved;
}
/**
* Verschieben einer Kategorie in eine andere.
*
* @param int $from_cat KategorieId der Kategorie, die verschoben werden soll (Quelle)
* @param int $to_cat KategorieId der Kategorie, IN die verschoben werden soll (Ziel)
*
* @return bool TRUE bei Erfolg, sonst FALSE
*/
public static function moveCategory($from_cat, $to_cat)
{
$from_cat = (int) $from_cat;
$to_cat = (int) $to_cat;
if ($from_cat == $to_cat) {
// kann nicht in gleiche kategroie kopiert werden
return false;
} else {
// kategorien vorhanden ?
// ist die zielkategorie im pfad der quellkategeorie ?
$fcat = rex_sql::factory();
$fcat->setQuery('select * from ' . rex::getTablePrefix() . 'article where startarticle=1 and id=? and clang_id=?', [$from_cat, rex_clang::getStartId()]);
$tcat = rex_sql::factory();
$tcat->setQuery('select * from ' . rex::getTablePrefix() . 'article where startarticle=1 and id=? and clang_id=?', [$to_cat, rex_clang::getStartId()]);
if ($fcat->getRows() != 1 or $tcat->getRows() != 1 && $to_cat != 0) {
// eine der kategorien existiert nicht
return false;
} else {
if ($to_cat > 0) {
$tcats = explode('|', $tcat->getValue('path'));
if (in_array($from_cat, $tcats)) {
// zielkategorie ist in quellkategorie -> nicht verschiebbar
return false;
}
}
// ----- folgende cats regenerate
$RC = [];
$RC[$fcat->getValue('parent_id')] = 1;
$RC[$from_cat] = 1;
$RC[$to_cat] = 1;
if ($to_cat > 0) {
$to_path = $tcat->getValue('path') . $to_cat . '|';
} else {
$to_path = '|';
}
$from_path = $fcat->getValue('path') . $from_cat . '|';
$gcats = rex_sql::factory();
// $gcats->setDebug();
$gcats->setQuery('select * from ' . rex::getTablePrefix() . 'article where path like ? and clang_id=?', [$from_path . '%', rex_clang::getStartId()]);
$up = rex_sql::factory();
// $up->setDebug();
for ($i = 0; $i < $gcats->getRows(); ++$i) {
// make update
$new_path = $to_path . $from_cat . '|' . str_replace($from_path, '', $gcats->getValue('path'));
$icid = $gcats->getValue('id');
// path aendern und speichern
$up->setTable(rex::getTablePrefix() . 'article');
$up->setWhere("id={$icid}");
$up->setValue('path', $new_path);
$up->update();
// cat in gen eintragen
$RC[$icid] = 1;
$gcats->next();
}
// ----- clang holen, max catprio holen und entsprechen updaten
$gmax = rex_sql::factory();
$up = rex_sql::factory();
// $up->setDebug();
foreach (rex_clang::getAllIds() as $clang) {
$gmax->setQuery('select max(catpriority) from ' . rex::getTablePrefix() . "article where parent_id={$to_cat} and clang_id=" . $clang);
$catpriority = (int) $gmax->getValue('max(catpriority)');
$up->setTable(rex::getTablePrefix() . 'article');
$up->setWhere("id={$from_cat} and clang_id={$clang} ");
$up->setValue('path', $to_path);
$up->setValue('parent_id', $to_cat);
$up->setValue('catpriority', $catpriority + 1);
$up->update();
}
// ----- generiere artikel neu - ohne neue inhaltsgenerierung
foreach ($RC as $id => $key) {
rex_article_cache::delete($id);
}
foreach (rex_clang::getAllIds() as $clang) {
self::newCatPrio($fcat->getValue('parent_id'), $clang, 0, 1);
}
}
}
return true;
}
/**
* Generiert den Artikel-Cache des Artikelinhalts.
*
* @param int $article_id Id des zu generierenden Artikels
* @param int $clang ClangId des Artikels
*
* @return bool TRUE bei Erfolg, FALSE wenn eine ungütlige article_id übergeben wird, sonst eine Fehlermeldung
*/
public static function generateArticleContent($article_id, $clang = null)
{
foreach (rex_clang::getAllIds() as $_clang) {
if ($clang !== null && $clang != $_clang) {
continue;
}
$CONT = new rex_article_content_base();
$CONT->setCLang($_clang);
$CONT->setEval(false);
// Content nicht ausführen, damit in Cachedatei gespeichert werden kann
if (!$CONT->setArticleId($article_id)) {
return false;
}
// --------------------------------------------------- Artikelcontent speichern
$article_content_file = rex_path::addonCache('structure', "{$article_id}.{$_clang}.content");
$article_content = $CONT->getArticle();
// ----- EXTENSION POINT
$article_content = rex_extension::registerPoint(new rex_extension_point('GENERATE_FILTER', $article_content, ['id' => $article_id, 'clang' => $_clang, 'article' => $CONT]));
if (rex_file::put($article_content_file, $article_content) === false) {
return rex_i18n::msg('article_could_not_be_generated') . ' ' . rex_i18n::msg('check_rights_in_directory') . rex_path::addonCache('structure');
}
}
return true;
}
/**
* Verschieben eines Artikels von einer Kategorie in eine Andere.
*
* @param int $id ArtikelId des zu verschiebenden Artikels
* @param int $from_cat_id KategorieId des Artikels, der Verschoben wird
* @param int $to_cat_id KategorieId in die der Artikel verschoben werden soll
*
* @return bool TRUE bei Erfolg, sonst FALSE
*/
public static function moveArticle($id, $from_cat_id, $to_cat_id)
{
$id = (int) $id;
$to_cat_id = (int) $to_cat_id;
$from_cat_id = (int) $from_cat_id;
if ($from_cat_id == $to_cat_id) {
return false;
}
// Artikel in jeder Sprache verschieben
foreach (rex_clang::getAllIds() as $clang) {
// validierung der id & from_cat_id
$from_sql = rex_sql::factory();
$from_sql->setQuery('select * from ' . rex::getTablePrefix() . 'article where clang_id="' . $clang . '" and startarticle<>1 and id="' . $id . '" and parent_id="' . $from_cat_id . '"');
if ($from_sql->getRows() == 1) {
// validierung der to_cat_id
$to_sql = rex_sql::factory();
$to_sql->setQuery('select * from ' . rex::getTablePrefix() . 'article where clang_id="' . $clang . '" and startarticle=1 and id="' . $to_cat_id . '"');
if ($to_sql->getRows() == 1 || $to_cat_id == 0) {
if ($to_sql->getRows() == 1) {
$parent_id = $to_sql->getValue('id');
$path = $to_sql->getValue('path') . $to_sql->getValue('id') . '|';
$catname = $to_sql->getValue('catname');
} else {
// In RootEbene
$parent_id = 0;
$path = '|';
$catname = $from_sql->getValue('name');
}
$art_sql = rex_sql::factory();
//$art_sql->setDebug();
$art_sql->setTable(rex::getTablePrefix() . 'article');
$art_sql->setValue('parent_id', $parent_id);
$art_sql->setValue('path', $path);
$art_sql->setValue('catname', $catname);
// Artikel als letzten Artikel in die neue Kat einfügen
$art_sql->setValue('priority', '99999');
// Kopierter Artikel offline setzen
$art_sql->setValue('status', $from_sql->getValue('status'));
$art_sql->addGlobalUpdateFields();
$art_sql->setWhere('clang_id="' . $clang . '" and startarticle<>1 and id="' . $id . '" and parent_id="' . $from_cat_id . '"');
$art_sql->update();
// Prios neu berechnen
self::newArtPrio($to_cat_id, $clang, 1, 0);
self::newArtPrio($from_cat_id, $clang, 1, 0);
} else {
return false;
}
} else {
return false;
}
}
// Caches des Artikels löschen, in allen Sprachen
rex_article_cache::delete($id);
// Caches der Kategorien löschen, da sich derin befindliche Artikel geändert haben
rex_article_cache::delete($from_cat_id);
rex_article_cache::delete($to_cat_id);
return true;
}
public function getClangs()
{
return $this->hasAll() ? rex_clang::getAllIds() : $this->perms;
}
$category_id = rex_category::get($category_id) ? $category_id : 0;
$article_id = rex_article::get($article_id) ? $article_id : 0;
$clang = rex_clang::exists($clang) ? $clang : rex_clang::getStartId();
// --------------------------------------------- Mountpoints
$mountpoints = rex::getUser()->getComplexPerm('structure')->getMountpoints();
if (count($mountpoints) == 1 && $category_id == 0) {
// Nur ein Mointpoint -> Sprung in die Kategory
$category_id = current($mountpoints);
}
// --------------------------------------------- Rechte prüfen
$KATPERM = rex::getUser()->getComplexPerm('structure')->hasCategoryPerm($category_id);
$stop = false;
if (rex_clang::count() > 1) {
if (!rex::getUser()->getComplexPerm('clang')->hasPerm($clang)) {
$stop = true;
foreach (rex_clang::getAllIds() as $key) {
if (rex::getUser()->getComplexPerm('clang')->hasPerm($key)) {
$clang = $key;
$stop = false;
break;
}
}
if ($stop) {
echo rex_view::error('You have no permission to this area');
exit;
}
}
} else {
$clang = rex_clang::getStartId();
}
$context = new rex_context(['page' => 'structure', 'category_id' => $category_id, 'article_id' => $article_id, 'clang' => $clang]);
public static function generatePathFile($params)
{
$setDomain = function (rex_yrewrite_domain &$domain, &$path, rex_structure_element $element) {
$id = $element->getId();
$clang = $element->getClang();
if (isset(rex_yrewrite::$domainsByMountId[$id][$clang])) {
$domain = rex_yrewrite::$domainsByMountId[$id][$clang];
$path = rex_yrewrite::$scheme->getClang($clang, $domain);
}
};
$setPath = function (rex_yrewrite_domain $domain, $path, rex_article $art) use($setDomain) {
$setDomain($domain, $path, $art);
if (($redirection = rex_yrewrite::$scheme->getRedirection($art, $domain)) instanceof rex_structure_element) {
rex_yrewrite::$paths['redirections'][$art->getId()][$art->getClang()] = ['id' => $redirection->getId(), 'clang' => $redirection->getClang()];
unset(rex_yrewrite::$paths['paths'][$domain->getName()][$art->getId()][$art->getClang()]);
return;
}
unset(rex_yrewrite::$paths['redirections'][$art->getId()][$art->getClang()]);
$url = rex_yrewrite::$scheme->getCustomUrl($art, $domain);
if (!is_string($url)) {
$url = rex_yrewrite::$scheme->appendArticle($path, $art, $domain);
}
rex_yrewrite::$paths['paths'][$domain->getName()][$art->getId()][$art->getClang()] = ltrim($url, '/');
};
$generatePaths = function (rex_yrewrite_domain $domain, $path, rex_category $cat) use(&$generatePaths, $setDomain, $setPath) {
$path = rex_yrewrite::$scheme->appendCategory($path, $cat, $domain);
$setDomain($domain, $path, $cat);
foreach ($cat->getChildren() as $child) {
$generatePaths($domain, $path, $child);
}
foreach ($cat->getArticles() as $art) {
$setPath($domain, $path, $art);
}
};
$ep = isset($params['extension_point']) ? $params['extension_point'] : '';
switch ($ep) {
// clang and id specific update
case 'CAT_DELETED':
case 'ART_DELETED':
foreach (self::$paths['paths'] as $domain => $c) {
unset(self::$paths['paths'][$domain][$params['id']]);
}
unset(self::$paths['redirections'][$params['id']]);
if (0 == $params['re_id']) {
break;
}
$params['id'] = $params['re_id'];
// no break
// no break
case 'CAT_ADDED':
case 'CAT_UPDATED':
case 'CAT_STATUS':
case 'ART_ADDED':
case 'ART_UPDATED':
case 'ART_STATUS':
rex_article_cache::delete($params['id']);
$domain = self::$domainsByMountId[0][$params['clang']];
$path = self::$scheme->getClang($params['clang'], $domain);
$art = rex_article::get($params['id'], $params['clang']);
$tree = $art->getParentTree();
if ($art->isStartArticle()) {
$cat = array_pop($tree);
}
foreach ($tree as $parent) {
$path = self::$scheme->appendCategory($path, $parent, $domain);
$setDomain($domain, $path, $parent);
$setPath($domain, $path, rex_article::get($parent->getId(), $parent->getClang()));
}
if ($art->isStartArticle()) {
$generatePaths($domain, $path, $cat);
} else {
$setPath($domain, $path, $art);
}
break;
// update all
// update all
case 'CLANG_DELETED':
case 'CLANG_ADDED':
case 'CLANG_UPDATED':
//case 'ALL_GENERATED':
//case 'ALL_GENERATED':
default:
self::$paths = ['paths' => [], 'redirections' => []];
foreach (rex_clang::getAllIds() as $clangId) {
$domain = self::$domainsByMountId[0][$clangId];
$path = self::$scheme->getClang($clangId, $domain);
foreach (rex_category::getRootCategories(false, $clangId) as $cat) {
$generatePaths($domain, $path, $cat);
}
foreach (rex_article::getRootArticles(false, $clangId) as $art) {
$setPath($domain, $path, $art);
}
}
break;
}
rex_file::putCache(self::$pathfile, self::$paths);
}
} else {
$addWildcard->setValue('id', $id);
}
$addWildcard->setValue('clang_id', $clang_id);
$addWildcard->setValue('wildcard', $wildcard_name);
$addWildcard->setValue('replace', $wildcard_replaces[$clang_id]);
$addWildcard->addGlobalUpdateFields();
$addWildcard->addGlobalCreateFields();
$addWildcard->insert();
}
}
$func = '';
} else {
$success = $this->i18n('wildcard_edited');
$editWildcard = rex_sql::factory();
foreach (rex_clang::getAllIds() as $clang_id) {
if (isset($wildcard_replaces[$clang_id])) {
$editWildcard->setTable(rex::getTable('sprog_wildcard'));
$editWildcard->setWhere(['id' => $wildcard_id, 'clang_id' => $clang_id]);
$editWildcard->setValue('wildcard', $wildcard_name);
$editWildcard->setValue('replace', $wildcard_replaces[$clang_id]);
$editWildcard->addGlobalUpdateFields();
$editWildcard->update();
}
}
$func = '';
unset($wildcard_id);
}
}
if ($success != '') {
$message .= rex_view::success($success);
