Metainfoex.php | searchcode

/lib/WV2/Metainfoex.php

https://bitbucket.org/webvariants/extended-meta-infos
PHP | 329 lines | 148 code | 47 blank | 134 comment | 37 complexity | 553fc791cf7630db471bef73e0fca0d7 MD5 | raw file

<?php
/*
 * Copyright (c) 2010, webvariants GbR, http://www.webvariants.de
 *
 * This file is released under the terms of the MIT license. You can find the
 * complete text in the attached LICENSE file or online at:
 *
 * http://www.opensource.org/licenses/mit-license.php
 */

/**
 * @defgroup external Externe, öffentliche API
 */

/**
 * Hilfsklasse für das Addon
 *
 * Diese Klasse stellt eine Hand voll Methoden für die einzelnen Module dieses
 * Addons zur Verfügung.
 *
 * Diese Klasse ist nicht als öffentliche API gedacht, dafür gibt es
 * WV2_MetaProvider. Außerhalb des AddOns sollte sie daher *nicht* verwendet
 * werden. Die hier definierten Konstanten sind natürlich für jeden da, der ein
 * Interesse an ihnen hat ;-)
 *
 * @ingroup external
 */
abstract class WV2_Metainfoex {
	const TYPE_ARTICLE  = 0; ///< int  Metainfo-Typ für Artikel
	const TYPE_CATEGORY = 1; ///< int  Metainfo-Typ für Kategorien
	const TYPE_MEDIUM   = 2; ///< int  Metainfo-Typ für Medien

	protected static $statCache = array(); ///< array Cache für DB-Ergebnisse

	public static function clearStatCache() {
		self::$statCache = array();
	}

	public static function clearDataCache() {
		sly_Core::cache()->flush('metainfoex', true);
	}

	public static function clearAllCaches() {
		self::clearDataCache();
		self::clearStatCache();
	}

	/**
	 * Hilfsmethode zu den Benutzerrechten
	 *
	 * Diese Methode ermittelt, ob der aktuelle Benutzer das angegebene Recht
	 * hat.
	 *
	 * @param  string $right  das Benutzerrecht (nur ExtMetaInfos-Rechte!)
	 * @return bool           true, wenn das Recht vorhanden ist, sonst false
	 */
	public static function isAllowed($right) {
		return _WV2_Metainfoex::isAllowed($right);
	}

	/**
	 * Ermitteln einer Datei-ID
	 *
	 * Diese Methode ermittelt zu einem Dateinamen die dazugehörige ID.
	 *
	 * @param  mixed $medium  der Dateiname (ohne Pfad!) (String) oder die ID (wird als int ungeändert zurückgegeben)
	 * @return int            die ID oder -1 falls keine gefunden wurde
	 */
	public static function getIDForMedium($medium) {
		if (sly_Util_String::isInteger($medium)) return (int) $medium;
		if ($medium instanceof OOMedia) return (int) $medium->getId();

		if (is_string($medium)) {
			$cacheKey = 'file_'.$medium;

			if (!isset(self::$statCache[$cacheKey])) {
				$sql = WV_SQLEx::getInstance();
				$id  = $sql->safeFetch('id', 'file', 'filename = ?', $medium);

				if ($id === false) {
					trigger_error('Konnte Datei-ID für "'.$medium.'" nicht ermitteln!', E_USER_WARNING);
				}

				self::$statCache[$cacheKey] = $id === false ? -1 : (int) $id;
			}

			return self::$statCache[$cacheKey];
		}

		trigger_error('Konnte Datei-ID für "'.$medium.'" ('.gettype($medium).') nicht ermitteln!', E_USER_WARNING);
		return -1;
	}

	/**
	 * Ermitteln einer Artikel-ID
	 *
	 * Diese Methode ermittelt zu einem Artikel die dazugehörige ID.
	 *
	 * @param  mixed $article  OOArticle, rex_article oder int
	 * @return int             die ID oder -1 falls keine gefunden wurde
	 */
	public static function getIDForArticle($article) {
		return WV_Sally::getIDForArticle($article);
	}

	/**
	 * Ermitteln einer Kategorie-ID
	 *
	 * Diese Methode ermittelt zu einer Kategorie die dazugehörige ID.
	 *
	 * @param  mixed $category  OOCategory, rex_article oder int
	 * @return int              die ID oder -1 falls keine gefunden wurde
	 */
	public static function getIDForCategory($category) {
		if (sly_Util_String::isInteger($category)) return (int) $category;
		if ($category instanceof OOCategory) return (int) $category->getId();
		if ($category instanceof rex_article) return (int) $category->getArticleId();
		trigger_error('Konnte Kategorie-ID für "'.$category.'" ('.gettype($category).') nicht ermitteln!', E_USER_WARNING);
		return -1;
	}

	/**
	 * Ermitteln einer Metainfo-ID
	 *
	 * Diese Methode ermittelt zu einer Metainfo die dazugehörige ID.
	 *
	 * @param  mixed $metainfo   int, string, _WV2_MetaInfo, _WV2_MetaData
	 * @param  int   $type       der Typ der Metainfo
	 * @param  bool  $allowNull  wenn true, wird für $metainfo = null auch null zurückgegeben
	 * @return int               die ID oder -1 falls keine gefunden wurde
	 */
	public static function getIDForMetainfo($metainfo, $type = WV2_Metainfoex::TYPE_ARTICLE, $allowNull = true) {
		if ($metainfo === null && $allowNull) return null; /* <- bedeutet im MetaProvider: "gib mir alle Metainfos!" */
		if (sly_Util_String::isInteger($metainfo)) return (int) $metainfo;
		if (is_string($metainfo)) return _WV2_MetaInfo::getIDForName($metainfo, $type);
		if ($metainfo instanceof _WV2_MetaInfo) return (int) $metainfo->getID();
		if ($metainfo instanceof _WV2_MetaData) return (int) $metainfo->getMetaInfoID();
		trigger_error('Konnte Metainfo-ID für "'.$metainfo.'" ('.gettype($metainfo).') nicht ermitteln!', E_USER_WARNING);
		return -1;
	}

	/**
	 * Ermitteln einer Objekt-ID
	 *
	 * Diese Methode ermittelt zu einem Objekt die dazugehörige ID.
	 *
	 * @param  mixed $object     int, null, OOArticle, OOCategory, OOMedia, rex_article
	 * @param  bool  $allowNull  wenn true, wird für $object = null auch null zurückgegeben
	 * @return int               die ID oder -1 falls keine gefunden wurde
	 */
	public static function getIDForObject($object, $allowNull = true) {
		if ($object === null && $allowNull) return null; /* <- bedeutet im MetaProvider: "gib mir alle Metainfos!" */
		if (sly_Util_String::isInteger($object)) return (int) $object; /* <- Artikel, Kategorie, Medium? Keine Ahnung. */
		if ($object instanceof OOArticle) return (int) $object->getId();
		if ($object instanceof OOCategory) return (int) $object->getId();
		if ($object instanceof OOMedia) return (int) $object->getId();
		if ($object instanceof rex_article) return (int) $object->getArticleId();
		trigger_error('Konnte Object-ID für "'.$object.'" ('.gettype($object).') nicht ermitteln!', E_USER_WARNING);
		return -1;
	}

	/**
	 * Wandelt Artikeltypen um
	 *
	 * Diese Hilfsmethode wandelt einen Artikeltyp, der als String gegeben wurde,
	 * in seine ID um. Wird kein String übergeben, wird der Parameter ungeändert
	 * zurückgegeben.
	 *
	 * @throws Exception            falls der Artikeltyp als String gegeben ist, dieser aber nicht existiert
	 * @param  mixed  $articleType  der Artikeltyp als String oder Integer oder _WV2_ArticleType
	 * @param  bool   $allowNull    wenn true, wird für $articleType = null auch null zurückgegeben
	 * @return int                  der Artikeltyp als Integer
	 */
	public static function getIDForArticleType($articleType, $allowNull) {
		if ($articleType === null && $allowNull) return null;
		if ($articleType instanceof _WV2_ArticleType) return $articleType->getID();
		if (!sly_Util_String::isInteger($articleType)) return _WV2_ArticleType::getIDForName($articleType);
		return (int) $articleType;
	}

	/*@}*/


	/*
	   ************************************************************
	     Hilfsmethoden für Metainfo-Typen
	   ************************************************************
	*/

	/** @name Hilfsmethoden für Objekte und Metatypen */

	/*@{*/


	/**
	 * Objekt erzeugen
	 *
	 * Diese Methode erzeugt für eine ID, eine Sprache und einen bestimmten Typ
	 * das dazugehörige Objekt (OOArticle, OOCategory oder OOMedia). Damit sind
	 * alle Methoden des AddOns von der lästigen Arbeit, ein 5-Zeilen-switch zu
	 * schreiben, befreit.
	 *
	 * @see    getTypeForObject
	 * @throws WV2_Exception falls der Typ nicht erkannt wurde
	 *
	 * @param  int $id     die ID des Objekts
	 * @param  int $clang  die Sprache des Objekts (für OOMedia irrelevant)
	 * @param  int $type   der Typ des Objekts
	 * @return object      ein passendes Objekt
	 */
	public static function getObject($id, $clang = WV_Sally::CLANG_CURRENT, $type = self::TYPE_ARTICLE) {
		$id    = (int) $id;
		$clang = WV_Sally::clang($clang);

		switch ($type) {
			case self::TYPE_ARTICLE:  return OOArticle::getArticleById($id, $clang);
			case self::TYPE_CATEGORY: return OOCategory::getCategoryById($id, $clang);
			case self::TYPE_MEDIUM:   return OOMedia::getMediaById($id);
		}

		throw new WV2_Exception('Unrecognized object type given: '.$type);
	}

	/**
	 * Typ ermitteln
	 *
	 * Diese Methode ermittelt für ein bestehendes Objekt die entsprechende
	 * Typ-Konstante.
	 *
	 * Wird das Objekt nicht erkannt, wird mit einem E_USER_ERROR die Ausführung
	 * des Scripts angehalten.
	 *
	 * @see    getObject
	 * @throws WV2_Exception  falls das Objekt nicht erkannt wurde
	 *
	 * @param  object $obj  das Objekt, dessen Typ ermittelt werden soll
	 * @return int          die Typ-ID des Objekts
	 */
	public static function getTypeForObject($obj) {
		if ($obj instanceof OOArticle)  return self::TYPE_ARTICLE;
		if ($obj instanceof OOCategory) return self::TYPE_CATEGORY;
		if ($obj instanceof OOMedia)    return self::TYPE_MEDIUM;

		throw new WV2_Exception('Unrecognizable class object given.');
	}

	/**
	 * Gibt einen Artikeltyp zurück
	 *
	 * @param  mixed  $articleType  der Artikeltyp als String oder Integer oder _WV2_ArticleType
	 * @return _WV2_ArticleType     der Artikeltyp als _WV2_ArticleType oder null, falls er nicht gefunden wurde
	 */
	public static function getArticleType($articleType) {
		try {
			return _WV2_ArticleType::getInstance(self::getIDForArticleType($articleType, false));
		}
		catch (WV2_Exception $e) {
			return null;
		}
	}

	/*@}*/

	public static function createMetaInfo($type, $name, $title, $datatype, $params, $helptext, $default, $hidden = false, $separatePage = false, $arttypes = array()) {
		if (!in_array($type, array(self::TYPE_ARTICLE, self::TYPE_CATEGORY, self::TYPE_MEDIUM))) {
			throw new WV2_Exception('Unbekannter Metainfo-Typ!');
		}

		if ($type != self::TYPE_ARTICLE) {
			$arttypes = array();
		}
		else {
			$arttypes = sly_makeArray($arttypes);

			foreach ($arttypes as $idx => $arttype) {
				$arttype = self::getIDForArticleType($arttype, false);

				if ($arttype <= 0) {
					unset($arttypes[$idx]);
				}
				else {
					$arttypes[$idx] = $arttype;
				}
			}

			$arttypes = array_unique($arttypes);
		}

		$separatePage = (boolean) $separatePage;
		$datatype     = (int) $datatype;
		$metainfoID   = _WV2_MetaInfo::create($name, $title, $separatePage, $datatype, $params, $default, $helptext, $arttypes, $type, $hidden);

		return _WV2_MetaInfo::getInstance($metainfoID, $type);
	}

	public static function createArticleType($name, $title, $metainfos = array()) {
		$metainfos = sly_makeArray($metainfos);

		foreach ($metainfos as $idx => $metainfo) {
			$metainfo = self::getIDForMetainfo($metainfo, self::TYPE_ARTICLE, false);

			if ($metainfo <= 0) {
				unset($metainfos[$idx]);
			}
			else {
				$metainfos[$idx] = $metainfo;
			}
		}

		$metainfos = array_unique($metainfos);
		$typeID    = _WV2_ArticleType::create($name, $title, $metainfos);

		return _WV2_ArticleType::getInstance($typeID);
	}

	public static function setMetaData($object, $clang, $metainfo, $value, $type) {
		$type       = (int) $type;
		$clang      = WV_Sally::clang($clang);
		$objectID   = self::getIDForObject($object, false);
		$metainfoID = self::getIDForMetainfo($metainfo, $type, false);

		self::clearAllCaches();

		return WV_SQLEx::getInstance()->queryEx(
			'UPDATE ~wv2_meta SET `value` = ? WHERE object_id = ? AND clang = ? AND metainfo_id = ? AND meta_type = ?',
			array($value, $objectID, $clang, $metainfoID, $type), '~'
		);
	}
}