...

pre

pre

 sections
		foreach ($preparsed as $pp) {
			$ret = str_replace($pp["key"], "
" . $pp["data"] . "
", $ret);
		}

		return $ret;
	}

	/**
	 * convenience function to process a $_REQUEST array
	 **/
	public function decodeAjaxRequest( &$pParamHash ){
		foreach( $pParamHash as $key => $value ){
			if( is_string($value) ){
				$pParamHash[$key] = htmlspecialchars_decode( $value );
			}
		}
	}

	/**
	 * Set content related mStructureId
	 *
	 * @param integer Structure ID
	 */
	public function setStructure( $pStructureId ) {
		if( $this->verifyId( $pStructureId ) ) {
			$this->mStructureId = $pStructureId;
		}
	}

	/**
	 * Check the number of structures that the content object is being used in
	 *
	 * @param integer Structure ID ( If null or not supplied check all structures )
	 * @return integer Number of structures that this content object is located in
	 */
	public function isInStructure( $pStructureId=null ) {
		if( $this->isValid() ) {
			$whereSql = null;
			$bindVars = [ $this->mContentId ];
			if( $pStructureId ) {
				array_push( $bindVars, $pStructureId );
				$whereSql = ' AND ls.`root_structure_id`=? ';
			}
			$query  = "SELECT `structure_id` FROM `".BIT_DB_PREFIX."liberty_structures` ls
					WHERE ls.`content_id`=? $whereSql";
			$cant = $this->mDb->getOne( $query, $bindVars );
			return $cant;
		}
		return 0;
	}

	/**
	 * This is a generic liberty content function to gather indexable words. Override this function
	 * in your BitPackage.php file if you need to add more indexable words from files other than
	 * tiki_content and users_users.
	 */
	public function setIndexData( $pContentId = 0 ) {
		global $gBitSystem ;
		if ( $pContentId == 0 ) $pContentId = $this->mContentId;
		$sql = "SELECT lc.`title`, lc.`data`, lcds.`data` AS `summary`, uu.`login`, uu.`real_name`
				FROM `" . BIT_DB_PREFIX . "liberty_content` lc
					INNER JOIN `" . BIT_DB_PREFIX . "users_users` uu ON uu.`user_id`    = lc.`user_id`
					LEFT OUTER JOIN `".BIT_DB_PREFIX."liberty_content_data` lcds ON (lc.`content_id` = lcds.`content_id` AND lcds.`data_type`='summary')
				WHERE lc.`content_id` = ?" ;
		$res = $gBitSystem->mDb->getRow($sql, [ $pContentId ]);
		if ( isset($res["title"] ) and !(isset($this->mInfo['no_index']) and $this->mInfo['no_index'] == true)) {
			$this->mInfo['index_data'] = $res["title"] . " " . $res["data"] . " " . $res["login"] . " " . $res["real_name"];
		}
	}

	// -------------------- Cache Funtions -------------------- //

	/**
	 * Check if content has a cache file
	 *
	 * @param array $pContentId Content id of cached item
	 * @access public
	 * @return string absolute path
	 */
	public function isCached( $pContentId = null ) {
		global $gBitSystem;
		return $gBitSystem->getConfig( 'liberty_cache' ) && is_file( LibertyContent::getCacheFile( $pContentId ));
	}

	/**
	 * Get the path where we store liberty cached content
	 *
	 * @access public
	 * @return string absolute path
	 */
	public static function getCacheBasePath() {
		return str_replace( '//', '/', TEMP_PKG_PATH.LIBERTY_PKG_NAME.'/cache/' );
	}

	/**
	 * Get the path to directory where an individual cache item is stored
	 *
	 * @param array $pContentId Content id of cached item
	 * @access public
	 * @return string path on success, false on failure
	 */
	public static function getCachePath( $pContentId = null ) {
		global $gBitSystem;

		$ret = false;
		if( BitBase::verifyId( $pContentId ) ) {
			if( $gBitSystem->isFeatureActive( 'liberty_flat_cache' )) {
				$subdir = floor( $pContentId / 1000 );
				$path = LibertyContent::getCacheBasePath().$subdir.'/';
			} else {
				$subdir = $pContentId % 1000;
				$path = LibertyContent::getCacheBasePath().$subdir.'/'.$pContentId.'/';
			}
			if( is_dir( $path ) || KernelTools::mkdir_p( $path ) ) {
				$ret = $path;
			}
		}

		return $ret;
	}

	/**
	 * Attempts to read from the specified cache file checking if the
	 * cached data has expired.
	 *
	 * @param string the name of the cache file from getCacheFile()
	 * @return string the contents of the cache file or null
	 */
	public static function readCacheFile( $pCacheFile ) {
		global $gBitSystem;
		$ret = null;
		if( is_file( $pCacheFile ) && ( time() - filemtime( $pCacheFile )) < $gBitSystem->getConfig('liberty_cache') && filesize( $pCacheFile ) > 0 ) {
			// get contents from cacgmstrftime(he file
			$h = fopen( $pCacheFile, 'r' );
			$ret = fread( $h, filesize( $pCacheFile ) );
			fclose( $h );
		}
		return $ret;
	}

	/**
	 * Unconditionally writes data to the cache file.
	 * Does not check for error assuming if write failed that the
	 * read will as well.
	 *
	 * @param string the name of the cache file from getCacheFile() to write
	 * @param string the contents to write to the file
	 */
	public static function writeCacheFile( $pCacheFile, $pData ) {
		// Cowardly refuse to write nothing.
		if( !empty( $pData )) {
			// write parsed contents to cache file
			$h = fopen( $pCacheFile, 'w' );
			fwrite( $h, $pData );
			fclose( $h );
		}
	}

	/**
	 * Get the path to file where an individual cache item is stored
	 *
	 * @param array $pContentId Content id of cached item
	 * @access public
	 * @return string filename on success, false on failure
	 */
	public static function getCacheFile( $pContentId = null, $pCacheExtension = null ) {
		if( $ret = LibertyContent::getCachePath( $pContentId ) ) {
			return $ret.$pContentId.( !empty( $pCacheExtension ) ? '.'.$pCacheExtension : '');
		}
			return false;

	}

	/**
	 * Delete cache files for a given content item
	 *
	 * @param array $pContentId
	 * @access public
	 * @return bool true on success, false on failure
	 */
	public static function expungeCacheFile( $pContentId = null ) {
		global $gBitSystem;
		if( $gBitSystem->isFeatureActive( 'liberty_cache' ) && BitBase::verifyId( $pContentId ) ) {
			// we need to unlink all files with the same id and any extension
			if( $dh = opendir( $cacheDir = LibertyContent::getCachePath( $pContentId ) ) ) {
				while( false !== ( $file = readdir( $dh ) ) ) {
					if( $file != '.' && $file != '..' && ( preg_match( "/^".$pContentId."$/", $file ) || preg_match( "/^".$pContentId."\..*/", $file ) ) ) {
						@unlink( $cacheDir.$file );
					}
				}
			}
		}

		return true;
	}

	/**
	 * Delete liberty cache
	 *
	 * @access public
	 * @return bool true on success, false on failure
	 */
	public static function expungeCache() {
		global $gBitSystem;
		$ret = false;
		if( $gBitSystem->isFeatureActive( 'liberty_cache' )) {
			$cacheDir = LibertyContent::getCacheBasePath();
			// make sure that we're in the temp dir at least
			if( strstr( $cacheDir, str_replace( '//', '/', TEMP_PKG_PATH ))) {
				KernelTools::unlink_r( $cacheDir );
				// make sure we have a usable cache directory to work with
				$ret = is_dir( $cacheDir ) || KernelTools::mkdir_p( $cacheDir );
			}
		}
		return $ret;
	}

	/**
	 * getFilter
	 *
	 * @param string $pContentTypeGuid
	 * @param string $pSql
	 * @param array $pBindVars
	 * @param array $pHash
	 * @access public
	 * @return void
	 * @todo
	 * - i think this function is not being used and will hopefully be removed soon - xing - Saturday Jul 07, 2007   19:54:02 CEST
	 * - it is called in getContentList but I think that services can do what it does now - nick - Sunday Sep 30, 2007
	 */
	public function getFilter( $pContentTypeGuid, &$pSql, &$pBindVars, $pHash = null): void {
		global $gLibertySystem, $gBitSystem;
		foreach ($gLibertySystem->mContentTypes as $type) {
			if ($type['content_type_guid'] == $pContentTypeGuid) {
				if( !empty( $gBitSystem->mPackages[$type['handler_package']]['path'] ) ) {
					$path = $gBitSystem->mPackages[$type['handler_package']]['path'];//constant(strtoupper($type['handler_package']).'_PKG_PATH');
					if( file_exists( $path.$type['handler_file'] ) ) {
						include_once $path.$type['handler_file'];
						if ( class_exists( $type['handler_class'] ) ) {
							$content = new $type['handler_class'];
							if (method_exists($content, 'getFilterSql')) {
								$content->getFilterSql($pSql, $pBindVars, $pHash);
							}
						}
					}
				}
			}
		}
	}

	// -------------------- Action Logging Funtions -------------------- //

	/**
	 * storeActionLog
	 * Note: use $gBitSystem throughout that this function can be called statically if needed
	 *
	 * @param array $pParamHash
	 * @return bool true on success, false on failure - mErrors will contain reason for failure
	 */
	public static function storeActionLogFromHash( $pParamHash = null ): void {
		global $gBitSystem;

		if( $gBitSystem->isFeatureActive( 'liberty_action_log' ) && $gBitSystem->verifyActionLog( $pParamHash ) ) {
			$gBitSystem->mDb->associateInsert( BIT_DB_PREFIX."liberty_action_log", $pParamHash['action_log_store'] );
		}
	}

	/**
	 * storeActionLog
	 * Note: use $gBitSystem throughout that this function can be called statically if needed
	 *
	 * @param array $pParamHash
	 * @return void
	 */
	public function storeActionLog( $pParamHash = null ) {
		global $gBitSystem;

		if( !empty( $this ) && BitBase::verifyId( $this->mContentId ) ) {
			$pParamHash['action_log']['content_id'] = $this->mContentId;
		}
		if( !empty( $this->mInfo['title'] ) ) {
			$pParamHash['action_log']['title'] = $this->mInfo['title'];
		}
		if( empty($pParamHash['action_log']['user_id']) && !empty( $pParamHash['user_id'] ) ) {
			$pParamHash['action_log']['user_id'] = $pParamHash['user_id'];
		}
		$log_message = '';
		if( empty( $pParamHash['action_log']['log_message'] ) && !empty( $this->mLogs ) ) {
			foreach( $this->mLogs as $key => $msg ) {
				$log_message .= "$msg";
			}
			$pParamHash['action_log']['log_message'] = $log_message;
		}
		$error_message = '';
		if( empty( $pParamHash['action_log']['error_message'] ) && !empty( $this->mErrors ) ) {
			foreach( $this->mErrors as $key => $msg ) {
				$error_message .= "$msg\n";
			}
			$pParamHash['action_log']['error_message'] = $error_message;
		}
		if( $gBitSystem->isFeatureActive( 'liberty_action_log' ) && $this->verifyActionLog( $pParamHash ) ) {
			$gBitSystem->mDb->associateInsert( BIT_DB_PREFIX."liberty_action_log", $pParamHash['action_log_store'] );
		}
	}

	/**
	 * verify the data in the action log is ready for storing
	 * First checks $pParamHash['action_log'] for information and then the content_store stuff
	 * Note: use $gBitSystem throughout that this function can be called statically if needed
	 *
	 * @param array $pParamHash
	 * @return bool true on success, false on failure
	 */
	public static function verifyActionLog( &$pParamHash ) {
		global $gBitUser, $gBitSystem;

		// we will set $ret false if there is a problem along the way
		// we can't populate mErrors since it would defeat the purpose having errors about the logging system
		$ret = true;

		// content_id isn't strictly needed
		if( BitBase::verifyId( $pParamHash['action_log']['content_id'] ) ) {
			$pParamHash['action_log_store']['content_id'] = $pParamHash['action_log']['content_id'];
		} elseif( BitBase::verifyId( $pParamHash['content_id'] ) ) {
			$pParamHash['action_log_store']['content_id'] = $pParamHash['content_id'];
		}
		// generic information needed in log
		$pParamHash['action_log_store']['user_id'] = !empty( $pParamHash['action_log']['user_id'] )
			? $pParamHash['action_log']['user_id'] : $gBitUser->mUserId;

		if( !empty( $pParamHash['action_log']['title'] ) ) {
			$pParamHash['action_log_store']['title'] = $pParamHash['action_log']['title'];
		} elseif( !empty( $pParamHash['content_store']['title'] ) ) {
			$pParamHash['action_log_store']['title'] = $pParamHash['content_store']['title'];
		} else {
			$ret = false;
		}
		// IP of the user
		if( empty( $pParamHash['action_log']['ip'] ) ) {
			if( !empty( $pParamHash['content_store']['ip'] ) ) {
				$pParamHash['action_log']['ip'] = $pParamHash['content_store']['ip'];
			} elseif( empty( $_SERVER["REMOTE_ADDR"] ) ) {
				$pParamHash['action_log']['ip'] = '127.0.0.1';
			} else {
				$pParamHash['action_log']['ip'] = $_SERVER["REMOTE_ADDR"];
			}
		}
		$pParamHash['action_log_store']['ip'] = $pParamHash['action_log']['ip'];
		$pParamHash['action_log_store']['last_modified'] = $gBitSystem->getUTCTime();

		// the log message
		$log_message = '';
		if( empty( $pParamHash['action_log']['log_message'] ) && !empty( $gBitSystem ) && !empty( $gBitSystem->mLogs ) ) {
			foreach( $gBitSystem->mLogs as $key => $msg ) {
				$log_message .= "$msg";
			}
		} elseif( !empty( $pParamHash['action_log']['log_message'] ) ) {
			$log_message = $pParamHash['action_log']['log_message'];
		}

		// trim down log
		if( !empty( $log_message ) ) {
			$pParamHash['action_log_store']['log_message'] = substr( $log_message, 0, 250 );
		}
		// error message - default is to put in any stuff in mErrors
		$error_message = '';
		if( !empty( $pParamHash['action_log']['error_message'] ) ) {
			$error_message = $pParamHash['action_log']['error_message'];
		}

		// trim down error message
		if( !empty( $error_message ) ) {
			$pParamHash['action_log_store']['error_message'] = substr( $error_message, 0, 250 );
		}

		if( empty( $pParamHash['action_log_store']['error_message'] ) && empty( $pParamHash['action_log_store']['log_message'] )) {
			$ret = false;
		}
		// if we get as far as here, we can
		return $ret;
	}

	/**
	 * Get a list of action log entries
	 *
	 * @param array $pListHash List options
	 * @access public
	 * @return array List of entries on success, false on failure
	 */
	public function getActionLogs( &$pListHash ) {
		LibertyContent::prepGetList( $pListHash );

		$ret = $bindVars = [];
		$selectSql = $joinSql = $orderSql = $whereSql = '';

		if( !empty( $pListHash['find'] ) ) {
			$whereSql .= empty( $whereSql ) ? ' WHERE ' : ' AND ';
			$whereSql .= " UPPER( lal.`log_message` ) LIKE ? ";
			$bindVars[] = '%'.strtoupper( $pListHash['find'] ).'%';
		}

		if( !empty( $pListHash['find_title'] ) ) {
			$whereSql .= empty( $whereSql ) ? ' WHERE ' : ' AND ';
			$whereSql .= " UPPER( lal.`title` ) LIKE ? ";
			$bindVars[] = '%'.strtoupper( $pListHash['find_log'] ).'%';
		}

		if( !empty( $pListHash['user_id'] ) ) {
			$whereSql .= empty( $whereSql ) ? ' WHERE ' : ' AND ';
			$whereSql .= " lal.`user_id` = ? ";
			$bindVars[] = $pListHash['user_id'];
		}

		if( !empty( $pListHash['content_id'] ) ) {
			$whereSql .= empty( $whereSql ) ? ' WHERE ' : ' AND ';
			$whereSql .= " lal.`content_id` = ? ";
			$bindVars[] = $pListHash['content_id'];
		}

		if( !empty( $pListHash['sort_mode'] )) {
			if( preg_match( "/^last_modified|^title/", $pListHash['sort_mode'] )) {
				$pListHash['sort_mode'] = "lal.".$pListHash['sort_mode'];
			}
			$orderSql = " ORDER BY ".$this->convertSortMode( $pListHash['sort_mode'] )." ";
		}

		$query = "
			SELECT lal.*,
				lc.`content_type_guid`, lc.`created`, lct.`content_name`, lct.`content_name_plural`,
				uue.`login` AS modifier_user, uue.`real_name` AS modifier_real_name
			FROM `".BIT_DB_PREFIX."liberty_action_log` lal
				LEFT OUTER JOIN `".BIT_DB_PREFIX."liberty_content` lc ON ( lc.`content_id` = lal.`content_id` )
				LEFT OUTER JOIN `".BIT_DB_PREFIX."liberty_content_types` lct ON ( lct.`content_type_guid` = lc.`content_type_guid` )
				LEFT OUTER JOIN `".BIT_DB_PREFIX."users_users` uue ON ( uue.`user_id` = lal.`user_id` )
			$whereSql $orderSql";

		$result = $this->mDb->query( $query, $bindVars, $pListHash['max_records'], $pListHash['offset'] );

		while( $aux = $result->fetchRow() ) {
			$aux['user']         = $aux['modifier_user'];
			$aux['editor']       = $aux['modifier_real_name'] ?? $aux['modifier_user'];
			$aux['display_name'] = RoleUser::getDisplayNameFromHash( $aux );
			$ret[]               = $aux;
		}

		$query = "SELECT COUNT( lal.`user_id` ) FROM `".BIT_DB_PREFIX."liberty_action_log` lal $whereSql";
		$pListHash['cant'] = $this->mDb->getOne( $query, $bindVars );
		LibertyContent::postGetList( $pListHash );

		return $ret;
	}

	/**
	 * expungeActionLog
	 *
	 * @param array $pTimeSpan Anything older than this timespan will be removed
	 * @access public
	 * @return bool true on success, false on failure - mErrors will contain reason for failure
	 */
	public function expungeActionLog( $pTimeSpan = null ) {
		global $gBitSystem;
		$where = '';
		$bindVars = [];
		if( BitBase::verifyId( $pTimeSpan ) ) {
			$where = "WHERE `last_modified` < ?";
			$bindVars[] = $gBitSystem->mServerTimestamp->getUTCTime() - $pTimeSpan;
		}
		$this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."liberty_action_log` $where", $bindVars );
		return true;
	}

	/**
	 * getAvailableContentStatus
	 *
	 * @access public
	 * @return array of content_status_id, content_status_names the current
	 * user can use on this content. Subclases may easily override with return
	 * LibertyContent::getAvailableContentStatus(-100, 0) for example to restrict to
	 * only hidden content types.
	 */
	public function getAvailableContentStatuses( $pUserMinimum=-100, $pUserMaximum=100 ) {
		global $gBitUser;
		if( $gBitUser->hasPermission( 'p_liberty_edit_all_status' )) {
			return $this->mDb->getAssoc( "SELECT `content_status_id`,`content_status_name` FROM `".BIT_DB_PREFIX."liberty_content_status` ORDER BY `content_status_id`" );
		}
			return $this->mDb->getAssoc( "SELECT `content_status_id`, `content_status_name` FROM `".BIT_DB_PREFIX."liberty_content_status` WHERE `content_status_id` > ? AND `content_status_id` < ? ORDER BY `content_status_id`", [ $pUserMinimum, $pUserMaximum ]);

	}

	/**
	 * getContentStatus will return the content status of the currently loaded content.
	 *
	 * @param array $pContentId Content ID of the content in question
	 * @access public
	 * @return int Status ID
	 */
	public function getContentStatus( $pDefault = 50, $pContentId = null ) {
		$ret = null;
		if ( @!BitBase::verifyId( $pContentId ) && $this->isValid() ){
			if ( !( $ret = $this->getField( 'content_status_id' ) ) ){
				$pContentId = $this->mContentId;
			}
		}
		if( !is_null( $pContentId )) {
			$ret = $this->mDb->getOne( "SELECT `content_status_id` FROM `".BIT_DB_PREFIX."liberty_content` WHERE `content_id` = ?", [ $pContentId ]);
		}
		$ret = is_null( $ret ) ? $pDefault : $ret;
		return $ret;
	}

	/**
	 * isDeleted status test
	 *
	 * @return bool true when the content status = -999
	 */
	public function isDeleted() {
		global $gBitSystem;
		return $this->getField( 'content_status_id' ) <= $gBitSystem->getConfig( 'liberty_status_deleted', -999 );
	}

	/**
	 * isPrivate status test
	 *
	 * @return bool true when the content status = -999
	 */
	public function isPrivate() {
		global $gBitSystem;
		return $this->getField( 'content_status_id' ) <= $gBitSystem->getConfig( 'liberty_status_threshold_private', -40 );
	}

	/**
	 * isProtected status test
	 *
	 * @return bool true when the content status = -20 or content has protection flag set
	 */
	public function isProtected() {
		global $gBitSystem;
		return $this->getField( 'content_status_id' ) <= $gBitSystem->getConfig( 'liberty_status_threshold_protected', -20 );
	}

	/**
	 * isHidden status test
	 *
	 * @return bool true when the content status = -10
	 */
	public function isHidden() {
		global $gBitSystem;
		return $this->getField( 'content_status_id' ) <= $gBitSystem->getConfig( 'liberty_status_threshold_hidden', -10 );
	}

	/**
	 * isHidden status test
	 *
	 * @return bool true when the content status = -10
	 */
	public function isPublic() {
		global $gBitSystem;
		return $this->getField( 'content_status_id' ) >= $gBitSystem->getConfig( 'liberty_status_threshold_public', 50 );
	}

	/**
	 * getContentStatusName
	 *
	 * @param array $pStatusId Status ID if not available in $this->mInfo['content_status_id']
	 * @access public
	 * @return string The name of the content status based on the status id of the content
	 */
	public function getContentStatusName( $pStatusId = null ) {
		$ret = 'Not a valid content status';

		// check to see where we can get the status information from
		if( !empty( $this ) && !empty( $this->mInfo['content_status_name'] )) {
			return $this->mInfo['content_status_name'];
		} elseif( is_null( $pStatusId ) && !empty( $this ) && !empty( $this->mInfo['content_status_id'] )) {
			$pStatusId = $this->mInfo['content_status_id'];
		}

		// fetch from db if needed
		if( !is_null( $pStatusId )) {
			if( $ret = $this->mDb->getOne( "SELECT `content_status_name` FROM `".BIT_DB_PREFIX."liberty_content_status` WHERE `content_status_id` = ?", [ $pStatusId ])) {
			}
		}

		return $ret;
	}

	/**
	 * Store Data into liberty_content_data
	 *
	 * @return bool true ( will not currently report a failure )
	 */
	public function storeData( $pData, $pType ) {
		if( $this->mContentId ) {
			$pData = trim( $pData  ?? '' );
			if( empty( $pData ) ) {
				$this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."liberty_content_data` WHERE `content_id`=? AND `data_type`=?", [ $this->mContentId, $pType ] );
			} else {
				if( $this->mDb->getOne( "SELECT `content_id` FROM `".BIT_DB_PREFIX."liberty_content_data` WHERE `content_id`=? AND `data_type`=?", [ $this->mContentId, $pType ] ) ) {
					$query = "UPDATE `".BIT_DB_PREFIX."liberty_content_data` SET `data`= ? WHERE `content_id` = ? AND `data_type`=?";
				} else {
					$query = "INSERT INTO `".BIT_DB_PREFIX."liberty_content_data` ( `data`, `content_id`, `data_type` ) VALUES (?,?,?)";
				}
				$result = $this->mDb->query( $query, [ $pData, $this->mContentId, $pType ] );
			}
		}
		return true;
	}

	/**
	 * storeStatus store liberty contenet status
	 *
	 * @param string $pContentStatusId
	 * @access public
	 * @return void
	 */
	public function storeStatus( $pContentStatusId ) {
		if( $this->isValid() && $pContentStatusId ) {
			return $this->mDb->query( "UPDATE `".BIT_DB_PREFIX."liberty_content` SET `content_status_id`=? WHERE `content_id`=?", [ $pContentStatusId, $this->mContentId ] );
		}
	}

	/**
	 * isCommentable will check allow_comments in mInfo or if it's set as a preference.
	 *
	 * @access public
	 * @return bool true on success, false on failure
	 */
	public function isCommentable() {
		if( $this->getPreference( 'allow_comments' ) == 'y' ) {
			return true;
		}
			$setting = $this->getField( 'allow_comments' );
			return $setting == true || $setting == 'y';

	}

	/**
	 * getListingPreview -- Returns a string with a preview of the content.
	 * @access public
	 * @return string the preview string
	 **/
	public function getListingPreview( $pMixed ) {
		global $gBitSystem, $gContent, $gBitSmarty;
		// TODO!
		return '';
	}

	/**
	 * getPreview -- Returns a string with a preview of the content. Default implementation runs getRenderFile() with $liberty_preview set in the context and gBitSystem set to only render the content.
	 *
	 * @access public
	 * @return string the preview string
	 **/
	public function getPreview() {
		global $gBitSystem, $gContent, $gBitSmarty, $gBitThemes;
		// Tell gBitSystem not to do modules and such
		$gBitThemes->setFormatHeader( "center_only" );
		// Tell the content we are previewing (in case they care)
		$gBitSmarty->assign('liberty_preview', true);
		// Save current gContent
		$oldGContent = $gContent;
		// Make us the content
		$gContent = $this;

		$ret = KernelTools::get_include_contents($this->getRenderFile());

		// Return gBitSystem to full render mode
		$gBitThemes->setFormatHeader( "html" );
		// Clear the preview flag
		$gBitSmarty->assign('liberty_preview', false);
		// Restore gContent
		$gContent = $oldGContent;

		return $ret;
	}

	// =========================================================================
	// Xref methods — generic for any LibertyContent subclass.
	// Queries scope to $this->mContentTypeGuid so each package sees only its
	// own liberty_xref_group / liberty_xref_item / liberty_xref rows.
	// =========================================================================

	/**
	 * Returns xref type groups (sort_order > 0) for this content type.
	 * Each row includes xref_type aliased as 'source' for template use.
	 */
	public function getXrefGroupList(): array {
		global $gBitUser;
		$roles    = array_keys( $gBitUser->mRoles );
		$bindVars = array_merge( $roles, [ $gBitUser->mUserId ] );
		$query = "SELECT g.*, g.`x_group` AS source FROM `".BIT_DB_PREFIX."liberty_xref_group` g
				  LEFT OUTER JOIN `".BIT_DB_PREFIX."users_roles_map` purm ON ( purm.`user_id`=".$gBitUser->mUserId." ) AND ( purm.`role_id`=g.`role_id` )
				  WHERE g.`content_type_guid` = '".$this->mContentTypeGuid."' AND g.`sort_order` > 0 AND (g.`role_id` IN(". implode(',', array_fill(0, count($roles), '?')) ." ) OR purm.`user_id`=?)
				  ORDER BY g.`sort_order`";
		$result = $this->mDb->query( $query, $bindVars );
		$ret = [];
		while ( $res = $result->fetchRow() ) {
			$ret[] = $res;
		}
		return $ret;
	}

	/**
	 * Returns xref sources at sort_order=0 (the top-level type/category markers).
	 */
	public function getXrefSourceList(): array {
		global $gBitUser;
		$roles    = array_keys( $gBitUser->mRoles );
		$bindVars = array_merge( $roles, [ $gBitUser->mUserId ] );
		$query = "SELECT g.`cross_ref_title` AS `type_name`, g.`item` FROM `".BIT_DB_PREFIX."liberty_xref_item` g
				  JOIN `".BIT_DB_PREFIX."liberty_xref_group` t ON t.`x_group` = g.`x_group` AND t.`content_type_guid` = '".$this->mContentTypeGuid."'
				  LEFT OUTER JOIN `".BIT_DB_PREFIX."users_roles_map` purm ON ( purm.`user_id`=".$gBitUser->mUserId." ) AND ( purm.`role_id`=g.`role_id` )
				  WHERE g.`content_type_guid` = '".$this->mContentTypeGuid."' AND t.`sort_order` = 0 AND (g.`role_id` IN(". implode(',', array_fill(0, count($roles), '?')) ." ) OR purm.`user_id`=?)
				  ORDER BY g.`item`";
		$result = $this->mDb->query( $query, $bindVars );
		$ret = [];
		$cnt = 0;
		while ( $res = $result->fetchRow() ) {
			$ret[$cnt]['item'] = $res['item'];
			$ret[$cnt++]['name'] = trim( $res['type_name'] );
		}
		return $ret;
	}

	/**
	 * Returns available xref source types, optionally filtered by group (sort_order
	 * integer) or template name. Used to populate the add-xref type selector.
	 */
	public function getXrefTypeList( $xrefGroup = 0, $xrefTemplate = NULL ): array {
		if ( $xrefTemplate ) {
			$query = "SELECT s.`cross_ref_title` AS `type_name`, s.`item`, s.`template` FROM `".BIT_DB_PREFIX."liberty_xref_item` s
					  WHERE s.`content_type_guid` = '".$this->mContentTypeGuid."' AND s.`template` = '$xrefTemplate'
					  ORDER BY s.`cross_ref_title`";
			$result = $this->mDb->query( $query, [] );
		} elseif ( $xrefGroup > -1 ) {
			$query = "SELECT s.`cross_ref_title` AS `type_name`, s.`item`, s.`template` FROM `".BIT_DB_PREFIX."liberty_xref_item` s
					  JOIN `".BIT_DB_PREFIX."liberty_xref_group` t ON t.`x_group` = s.`x_group` AND t.`content_type_guid` = '".$this->mContentTypeGuid."'
					  LEFT JOIN `".BIT_DB_PREFIX."liberty_xref` x ON x.`item` = s.`item` AND x.`content_id` = ? AND ( x.`end_date` IS NULL OR x.`end_date` > CURRENT_TIMESTAMP )
					  WHERE s.`content_type_guid` = '".$this->mContentTypeGuid."' AND t.`sort_order` = ? AND ( x.`xref_id` IS NULL OR x.`xorder` > 0 )
					  ORDER BY s.`cross_ref_title`";
			$result = $this->mDb->query( $query, [ $this->mContentId, $xrefGroup ] );
		} else {
			$query = "SELECT s.`cross_ref_title` AS `type_name`, s.`item`, s.`template` FROM `".BIT_DB_PREFIX."liberty_xref_item` s
					  JOIN `".BIT_DB_PREFIX."liberty_xref_group` t ON t.`x_group` = s.`x_group` AND t.`content_type_guid` = '".$this->mContentTypeGuid."'
					  LEFT JOIN `".BIT_DB_PREFIX."liberty_xref` x ON x.`item` = s.`item` AND x.`content_id` = ? AND ( x.`end_date` IS NULL OR x.`end_date` > CURRENT_TIMESTAMP )
					  WHERE s.`content_type_guid` = '".$this->mContentTypeGuid."' AND t.`sort_order` > 0 AND ( x.`xref_id` IS NULL OR x.`xorder` > 0 )
					  ORDER BY s.`cross_ref_title`";
			$result = $this->mDb->query( $query, [ $this->mContentId ] );
		}
		$ret = [];
		while ( $res = $result->fetchRow() ) {
			$ret['list'][$res['item']] = trim( $res['type_name'] );
			$ret['type'][$res['item']] = trim( $res['template'] ) !== '' ? trim( $res['template'] ) : 'generic';
		}
		return $ret;
	}

	/**
	 * Returns distinct xref template format names for this content type.
	 */
	public function getXrefFormatList(): array {
		global $gBitUser;
		$roles    = array_keys( $gBitUser->mRoles );
		$bindVars = array_merge( $roles, [ $gBitUser->mUserId ] );
		$query = "SELECT DISTINCT g.`template` FROM `".BIT_DB_PREFIX."liberty_xref_item` g
				  LEFT OUTER JOIN `".BIT_DB_PREFIX."users_roles_map` purm ON ( purm.`user_id`=".$gBitUser->mUserId." ) AND ( purm.`role_id`=g.`role_id` )
				  WHERE g.`content_type_guid` = '".$this->mContentTypeGuid."' AND (g.`role_id` IN(". implode(',', array_fill(0, count($roles), '?')) ." ) OR purm.`user_id`=?)
				  ORDER BY g.`template`";
		$result = $this->mDb->query( $query, $bindVars );
		$ret = [];
		while ( $res = $result->fetchRow() ) {
			$ret[] = trim( $res['template'] ) !== '' ? trim( $res['template'] ) : 'generic';
		}
		return $ret;
	}

	/**
	 * Loads xref type markers (sort_order=0 sources, showing which categories apply
	 * to this content item) into mInfo[$this->mXrefTypeKey].
	 * Subclasses set $mXrefTypeKey to control the mInfo key (default: 'xref_types').
	 */
	public function loadXrefTypeList(): void {
		if ( $this->isValid() && empty( $this->mInfo[$this->mXrefTypeKey] ) ) {
			global $gBitUser;
			$roles    = array_keys( $gBitUser->mRoles );
			$bindVars = array_merge( [ $this->mContentId ], $roles, [ $gBitUser->mUserId ] );
			$sql = "SELECT r.`item`, r.`cross_ref_title`, d.`content_id`
					FROM `".BIT_DB_PREFIX."liberty_xref_item` r
					JOIN `".BIT_DB_PREFIX."liberty_xref_group` t ON t.`x_group` = r.`x_group` AND t.`content_type_guid` = '".$this->mContentTypeGuid."'
					LEFT JOIN `".BIT_DB_PREFIX."liberty_xref` d ON d.`content_id` = ? AND d.`item` = r.`item`
					LEFT OUTER JOIN `".BIT_DB_PREFIX."users_roles_map` purm ON ( purm.`user_id`=".$gBitUser->mUserId." ) AND ( purm.`role_id`=r.`role_id` )
					WHERE r.`content_type_guid` = '".$this->mContentTypeGuid."' AND t.`sort_order` = 0 AND (r.`role_id` IN(". implode(',', array_fill(0, count($roles), '?')) ." ) OR purm.`user_id`=?)
					ORDER BY r.`item`";
			$result = $this->mDb->query( $sql, $bindVars );
			while ( $res = $result->fetchRow() ) {
				$this->mInfo[$this->mXrefTypeKey][] = $res;
			}
		}
	}

	/**
	 * Loads all xref records for this content item into mInfo keyed by type_source
	 * (the liberty_xref_group.xref_type text key, or 'history' for expired records).
	 */
	public function loadXrefList(): void {
		if ( $this->isValid() && empty( $this->mInfo['xref'] ) ) {
			global $gBitUser;
			$roles    = array_keys( $gBitUser->mRoles );
			$bindVars = array_merge( [ $this->mDb->NOW(), $this->mContentId ], $roles, [ $gBitUser->mUserId ] );
			$sql = "SELECT s.`x_group`, x.`xref_id`, x.`last_update_date`, x.`item`, t.`title` AS type_title,
					CASE
					WHEN x.`end_date` < ? THEN 'history'
					ELSE t.`x_group` END AS type_source,
					CASE
					WHEN x.`xorder` = 0 THEN s.`cross_ref_title`
					ELSE s.`cross_ref_title` || '-' || x.`xorder` END
					AS source_title,
					x.`xref`, x.`xkey`, x.`xkey_ext`, x.`data`,
					x.`start_date`, x.`end_date`, s.`template`,
					pc.`add1` || ',' || pc.`add2` || ',' || pc.`add4` || ',' || pc.`town` AS address
					FROM `".BIT_DB_PREFIX."liberty_xref` x
					JOIN `".BIT_DB_PREFIX."liberty_xref_item` s ON s.`item` = x.`item` AND s.`content_type_guid` = '".$this->mContentTypeGuid."'
					LEFT JOIN `".BIT_DB_PREFIX."address_postcode` pc ON pc.`postcode` = x.`xkey`
					JOIN `".BIT_DB_PREFIX."liberty_xref_group` t ON t.`x_group` = s.`x_group` AND t.`content_type_guid` = '".$this->mContentTypeGuid."'
					LEFT OUTER JOIN `".BIT_DB_PREFIX."users_roles_map` purm ON ( purm.`user_id`=".$gBitUser->mUserId." ) AND ( purm.`role_id`=s.`role_id` )
					WHERE x.`content_id` = ? AND (s.`role_id` IN(". implode(',', array_fill(0, count($roles), '?')) ." ) OR purm.`user_id`=?)
					ORDER BY x.`item`, x.`xorder`";
			$result = $this->mDb->query( $sql, $bindVars );
			if ( $result ) {
				while ( $res = $result->fetchRow() ) {
					$this->mInfo[$res['type_source']][] = $res;
				}
			}
		}
	}

	/**
	 * Loads a single xref record by xref_id and then loads the parent content item.
	 */
	public function loadXref( $pXrefId = NULL ): void {
		if ( BitBase::verifyId( $pXrefId ) ) {
			$xref = new LibertyXref();
			$xref->mContentTypeGuid = $this->mContentTypeGuid;
			$xref->load( $pXrefId );
			if ( $xref->mContentId ) {
				$this->load( $xref->mContentId );
				$this->mInfo['xref_title'] = $xref->mContentId;
				$this->mInfo['xref_store'] = $xref->mInfo;
				$this->mInfo['format_guid'] = 'text';
			}
		}
	}

	/**
	 * Stores or updates an xref record for this content item.
	 */
	public function storeXref( &$pParamHash ): bool {
		$xref = new LibertyXref();
		$xref->mContentTypeGuid = $this->mContentTypeGuid;
		if ( BitBase::verifyId( $pParamHash['xref_id'] ?? null ) ) {
			$xref->load( $pParamHash['xref_id'] );
		}
		if ( $xref->store( $pParamHash ) ) {
			$this->mInfo['xref_title'] = $xref->mContentId;
			$this->mInfo['xref_store'] = $xref->mInfo;
			$pParamHash['xref_id']     = $xref->mXrefId;
			$this->load();
			return true;
		}
		return false;
	}

	/**
	 * Steps (creates a new dated version of) an xref record for this content item.
	 */
	public function stepXref( &$pParamHash ): bool {
		$xref = new LibertyXref();
		$xref->mContentTypeGuid = $this->mContentTypeGuid;
		$xref->load( $pParamHash['xref_id'] );
		if ( $xref->stepXref( $pParamHash ) ) {
			$this->mInfo['xref_title'] = $xref->mContentId;
			$this->mInfo['xref_store'] = $xref->mInfo;
			$this->load();
			return true;
		}
		return false;
	}

}