1245 lines
51 KiB
PHP
1245 lines
51 KiB
PHP
<?php
|
|
# Copyright (c) 2003-2005, Jannis Hermanns (on behalf the Serendipity Developer Team)
|
|
# All rights reserved. See LICENSE file for licensing details
|
|
|
|
if (IN_serendipity !== true) {
|
|
die ("Don't hack!");
|
|
}
|
|
|
|
/**
|
|
* Fetch a list of trackbacks for an entry
|
|
*
|
|
* @access public
|
|
* @param int The ID of the entry
|
|
* @param string How many trackbacks to show
|
|
* @param boolean If true, also non-approved trackbacks will be shown
|
|
* @return
|
|
*/
|
|
function &serendipity_fetchTrackbacks($id, $limit = null, $showAll = false) {
|
|
global $serendipity;
|
|
|
|
if (!$showAll) {
|
|
$and = "AND status = 'approved'";
|
|
}
|
|
|
|
$query = "SELECT * FROM {$serendipity['dbPrefix']}comments WHERE entry_id = '". (int)$id ."' AND (type = 'TRACKBACK' OR type = 'PINGBACK') $and ORDER BY id";
|
|
if (isset($limit)) {
|
|
$limit = serendipity_db_limit_sql($limit);
|
|
$query .= " $limit";
|
|
}
|
|
|
|
$comments = serendipity_db_query($query);
|
|
if (!is_array($comments)) {
|
|
return array();
|
|
}
|
|
|
|
return $comments;
|
|
}
|
|
|
|
/**
|
|
* Show trackbacks for an entry
|
|
*
|
|
* LONG
|
|
*
|
|
* @access public
|
|
* @param array The superarray of trackbacks to display
|
|
* @return
|
|
*/
|
|
function &serendipity_printTrackbacks($trackbacks) {
|
|
global $serendipity;
|
|
|
|
$serendipity['smarty']->assignByRef('trackbacks', $trackbacks);
|
|
|
|
return serendipity_smarty_fetch('TRACKBACKS', 'trackbacks.tpl');
|
|
}
|
|
|
|
/**
|
|
* Formats a HTML5 timestamp; our serendipity_formatTime handler uses strftime() which does not have this shortcut
|
|
*
|
|
* @access public
|
|
* @param int The unix timestamp to format
|
|
* @return timestamp in ISO-format
|
|
*/
|
|
function serendipity_smarty_html5time($timestamp) {
|
|
return date("c", $timestamp);
|
|
}
|
|
|
|
|
|
/**
|
|
* Smarty: Fetch a smarty block and pass it on to Serendipity Templates - use with Smarty > 3.0 only
|
|
*
|
|
* @access public
|
|
* @param string The name of the block to parse data into ("COMMENTS" - virtual variable like {$COMMENTS})
|
|
* @param string The name of the template file to fetch. Only filename, the path is auto-detected
|
|
* @param boolean If true, the output of the smarty parser will be echoed instead of invisibly treated
|
|
* @param boolean If true, always use a tpl file from the frontend fallback chain (used for the preview)
|
|
* @return string The parsed HTML code
|
|
*/
|
|
function &serendipity_smarty_fetch($block, $file, $echo = false, $force_frontend = false) {
|
|
global $serendipity;
|
|
|
|
$output = $serendipity['smarty']->fetch('file:'. serendipity_getTemplateFile($file, 'serendipityPath', $force_frontend), null, null, null, ($echo === true && ($serendipity['smarty_raw_mode'] ?? null)));
|
|
|
|
$serendipity['smarty']->assignByRef($block, $output);
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Smarty Modifier: Check if a string is not empty and prepend a prefix in that case. Else, leave empty
|
|
*
|
|
* @access public
|
|
* @param string The input string to check
|
|
* @param string The prefix to prepend, if $string is not empty
|
|
* @return string The return string
|
|
*/
|
|
function serendipity_emptyPrefix($string, $prefix = ': ') {
|
|
return (!empty($string) ? $prefix . serendipity_specialchars($string) : '');
|
|
}
|
|
|
|
/**
|
|
* Smarty Modifier: Return a remembered variable
|
|
*
|
|
* @access public
|
|
* @param string The variable name
|
|
* @param string The wanted value
|
|
* @param boolean Force default?
|
|
* @param string Returned attribute
|
|
* @return string The return string
|
|
*/
|
|
function serendipity_ifRemember($name, $value, $isDefault = false, $att = 'checked') {
|
|
global $serendipity;
|
|
|
|
if (!is_array($serendipity['COOKIE']) && !$isDefault) {
|
|
return false;
|
|
}
|
|
|
|
if ((!is_array($serendipity['COOKIE']) && $isDefault) ||
|
|
(!isset($serendipity['COOKIE']['serendipity_' . $name]) && $isDefault) ||
|
|
(isset($serendipity['COOKIE']['serendipity_' . $name]) && $serendipity['COOKIE']['serendipity_' . $name] == $value)) {
|
|
|
|
return " $att=\"$att\" ";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Fetch and print a single or multiple entries
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* [FETCHING]
|
|
* category: (int) The category ID (separate multiple with ";") to fetch entries from
|
|
* viewAuthor: (int) The author ID (separate multiple with ";") to fetch entries from
|
|
* page: (int) The number of the page for paginating entries
|
|
* id: (int) The ID of an entry. If given, only a single entry will be fetched. If left empty, multiple entries are fetched.
|
|
* range: (mixed) Restricts fetching entries to a specific timespan. Behaves differently depending on the type:
|
|
* Numeric:
|
|
* YYYYMMDD - Shows all entries from YYYY-MM-DD.
|
|
* If DD is "00", it will show all entries from that month.
|
|
* If DD is any other number, it will show entries of that specific day.
|
|
* 2-Dimensional Array:
|
|
* Key #0 - Specifies the start timestamp (unix seconds)
|
|
* Key #1 - Specifies the end timestamp (unix seconds)
|
|
* Other (null, 3-dimensional Array, ...):
|
|
* Entries newer than $modified_since will be fetched
|
|
* full (boolean) Indicates if the full entry will be fetched (body+extended: TRUE), or only the body (FALSE).
|
|
* limit (string) Holds a "Y" or "X, Y" string that tells which entries to fetch. X is the first entry offset, Y is number of entries. If not set, the global fetchLimit will be applied (15 entries by default)
|
|
* fetchDrafts (boolean) Indicates whether drafts should be fetched (TRUE) or not
|
|
* modified_since (int) Holds a unix timestamp to be used in conjunction with $range, to fetch all entries newer than this timestamp
|
|
* orderby (string) Holds the SQL "ORDER BY" statement.
|
|
* filter_sql (string) Can contain any SQL code to inject into the central SQL statement for fetching the entry
|
|
* noCache (boolean) If set to TRUE, all entries will be fetched from scratch and any caching is ignored
|
|
* noSticky (boolean) If set to TRUE, all sticky entries will NOT be fetched.
|
|
* select_key (string) Can contain a SQL statement on which keys to select. Plugins can also set this, pay attention!
|
|
* group_by (string) Can contain a SQL statement on how to group the query. Plugins can also set this, pay attention!
|
|
* returncode (string) If set to "array", the array of entries will be returned. "flat-array" will only return the articles without their entryproperties. "single" will only return a 1-dimensional array. "query" will only return the used SQL.
|
|
* joinauthors (bool) Should an SQL-join be made to the AUTHORS DB table?
|
|
* joincategories (bool) Should an SQL-join be made to the CATEGORIES DB table?
|
|
* joinown (string) SQL-Parts to add to the "JOIN" query
|
|
* entryprops (string) Condition list of commaseparated entryproperties that an entry must have to be displayed (example: "ep_CustomField='customVal',ep_CustomField2='customVal2'")
|
|
*
|
|
* [PRINTING]
|
|
* template: (string) Name of the template file to print entries with
|
|
* preview: (boolean) Indicates if this is a preview
|
|
* block (string The name of the SMARTY block that this gets parsed into
|
|
* use_hooks (boolean Indicates whether to apply footer/header event hooks
|
|
* use_footer (boolean Indicates whether the pagination footer should be displayed
|
|
* groupmode (string Indicates whether the input $entries array is already grouped in preparation for the smarty $entries output array [TRUE], or if it shall be grouped by date [FALSE]
|
|
* skip_smarty_hooks (boolean) If TRUE, no plugins will be executed at all
|
|
* skip_smarty_hook (mixed) Can be set to an array of plugin hooks to NOT execute
|
|
* prevent_reset (boolean) If set to TRUE, the smarty $entries array will NOT be cleared. (to prevent possible duplicate output of entries)
|
|
* @param object Smarty object
|
|
* @return string The Smarty HTML response
|
|
*/
|
|
function serendipity_smarty_fetchPrintEntries($params, $smarty) {
|
|
global $serendipity;
|
|
static $entrycount = 0;
|
|
static $restore_var_GET_keys = array('category', 'viewAuthor', 'page', 'hide_category');
|
|
|
|
// A counter variable to not assign template files multiple times
|
|
$entrycount++;
|
|
|
|
// Default values for function calls
|
|
if (empty($params['template'])) {
|
|
$params['template'] = 'entries.tpl';
|
|
}
|
|
|
|
if (empty($params['range'])) {
|
|
$params['range'] = null;
|
|
}
|
|
|
|
if (empty($params['full'])) {
|
|
$params['full'] = true;
|
|
}
|
|
|
|
if (empty($params['fetchDrafts'])) {
|
|
$params['fetchDrafts'] = false;
|
|
}
|
|
|
|
if (!empty($params['entryprops'])) {
|
|
if (preg_match_all('@(.*)(!)?=[\'"]*([^\'"]+)[\'"]*(,|$)@imsU', $params['entryprops'], $m)) {
|
|
foreach($m[0] AS $idx => $p) {
|
|
$params['joinown'] .= "\n JOIN {$serendipity['dbPrefix']}entryproperties
|
|
AS ep" . $idx . "
|
|
ON (ep" . $idx . ".entryid = e.id AND
|
|
ep" . $idx . ".property = '" . serendipity_db_escape_string($m[1][$idx]) . "' AND
|
|
ep" . $idx . ".value " . $m[2][$idx] . "= '" . serendipity_db_escape_string($m[3][$idx]) . "') \n";
|
|
}
|
|
}
|
|
}
|
|
|
|
if (empty($params['modified_since'])) {
|
|
$params['modified_since'] = false;
|
|
}
|
|
|
|
if (empty($params['orderby'])) {
|
|
$params['orderby'] = 'timestamp DESC';
|
|
}
|
|
|
|
if (empty($params['noCache'])) {
|
|
$params['noCache'] = false;
|
|
}
|
|
|
|
if (empty($params['noSticky'])) {
|
|
$params['noSticky'] = false;
|
|
}
|
|
|
|
if (empty($params['preview'])) {
|
|
$params['preview'] = false;
|
|
}
|
|
|
|
if (empty($params['block'])) {
|
|
$params['block'] = 'smarty_entries_' . $entrycount;
|
|
}
|
|
|
|
if (empty($params['use_hooks'])) {
|
|
$params['use_hooks'] = false;
|
|
}
|
|
|
|
if (empty($params['use_footer'])) {
|
|
$params['use_footer'] = false;
|
|
}
|
|
|
|
if (empty($params['groupmode'])) {
|
|
$params['groupmode'] = 'date';
|
|
}
|
|
|
|
if (empty($params['skip_smarty_hooks'])) {
|
|
$params['skip_smarty_hooks'] = true;
|
|
}
|
|
|
|
if (empty($params['skip_smarty_hook'])) {
|
|
$params['skip_smarty_hook'] = array();
|
|
}
|
|
|
|
if (empty($params['prevent_reset'])) {
|
|
$params['prevent_reset'] = false;
|
|
}
|
|
|
|
if (empty($params['select_key'])) {
|
|
$params['select_key'] = null;
|
|
}
|
|
|
|
if (empty($params['group_by'])) {
|
|
$params['group_by'] = null;
|
|
}
|
|
|
|
if (empty($params['returncode'])) {
|
|
$params['returncode'] = 'array';
|
|
}
|
|
|
|
if (empty($params['joinauthors'])) {
|
|
$params['joinauthors'] = true;
|
|
}
|
|
|
|
if (empty($params['joincategories'])) {
|
|
$params['joincategories'] = true;
|
|
}
|
|
|
|
// Some functions deal with the $serendipity array. To modify them, we need to store
|
|
// their original contents.
|
|
$old_var = array();
|
|
if (!empty($params['short_archives'])) {
|
|
$old_var['short_archives'] = $serendipity['short_archives'];
|
|
$serendipity['short_archives'] = $params['short_archives'];
|
|
}
|
|
|
|
$old_var['skip_smarty_hooks'] = $serendipity['skip_smarty_hooks'] ?? null;
|
|
$serendipity['skip_smarty_hooks'] = $params['skip_smarty_hooks'];
|
|
|
|
$old_var['skip_smarty_hook'] = $serendipity['skip_smarty_hook'] ?? null;
|
|
$serendipity['skip_smarty_hook'] = $params['skip_smarty_hook'];
|
|
|
|
foreach($restore_var_GET_keys AS $key) {
|
|
if (!empty($params[$key])) {
|
|
$old_var['GET'][$key] = $serendipity['GET'][$key] ?? null;
|
|
$serendipity['GET'][$key] = $params[$key];
|
|
}
|
|
}
|
|
|
|
$param_keys = array(
|
|
'full',
|
|
'limit',
|
|
'fetchDrafts',
|
|
'modified_since',
|
|
'orderby',
|
|
'filter_sql',
|
|
'noCache',
|
|
'noSticky',
|
|
'select_key',
|
|
'group_by',
|
|
'returncode',
|
|
'joinauthors',
|
|
'joincategories',
|
|
'joinown'
|
|
);
|
|
foreach ($param_keys as $param_key) {
|
|
if (!isset($params[$param_key])) {
|
|
$params[$param_key] = null;
|
|
}
|
|
}
|
|
if (!empty($params['id'])) {
|
|
$entry = serendipity_fetchEntry(
|
|
'id',
|
|
(int)$params['id'],
|
|
$params['full'],
|
|
$params['fetchDrafts']);
|
|
} else {
|
|
$entry = serendipity_fetchEntries(
|
|
$params['range'],
|
|
$params['full'],
|
|
$params['limit'],
|
|
$params['fetchDrafts'],
|
|
$params['modified_since'],
|
|
$params['orderby'],
|
|
$params['filter_sql'],
|
|
$params['noCache'],
|
|
$params['noSticky'],
|
|
$params['select_key'],
|
|
$params['group_by'],
|
|
$params['returncode'],
|
|
$params['joinauthors'],
|
|
$params['joincategories'],
|
|
$params['joinown']
|
|
);
|
|
|
|
// Check whether the returned entries shall be grouped specifically
|
|
switch ($params['groupmode']) {
|
|
case 'date':
|
|
// No regrouping required, printEntries() does it for us.
|
|
break;
|
|
|
|
case 'category':
|
|
// Regroup by primary category
|
|
|
|
$groupdata = array();
|
|
foreach($entry AS $k => $_entry) {
|
|
|
|
if (is_array($entry['categories'])) {
|
|
$groupkey = $entry['categories'][0];
|
|
} else {
|
|
$groupkey = 'none';
|
|
}
|
|
$groupdata[$groupkey]['entries'] =& $_entry;
|
|
}
|
|
$entry =& $groupdata;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ($params['returncode'] == 'query') {
|
|
return print_r($entry, true);
|
|
}
|
|
|
|
serendipity_printEntries(
|
|
$entry, // Entry data
|
|
(!empty($params['id']) ? true : false), // Extended data?
|
|
$params['preview'], // Entry preview?
|
|
'ENTRIES',
|
|
false, // Prevent Smarty parsing
|
|
$params['use_hooks'],
|
|
$params['use_footer'],
|
|
($params['groupmode'] == 'date' ? false : true) // Grouping of $entry
|
|
);
|
|
|
|
// Restore the $serendipity array after our modifications.
|
|
if (isset($old_var['short_archives'])) {
|
|
$serendipity['short_archives'] = $old_var['short_archives'];
|
|
}
|
|
|
|
if (is_array($old_var['GET'] ?? null)) {
|
|
foreach($old_var['GET'] AS $key => $val) {
|
|
$serendipity['GET'][$key] = $val;
|
|
}
|
|
}
|
|
|
|
$out = serendipity_smarty_fetch($params['block'], $params['template']);
|
|
// Reset array list, because we might be in a nested code call.
|
|
if ($params['prevent_reset'] == false) {
|
|
$serendipity['smarty']->assign('entries', array());
|
|
}
|
|
$serendipity['skip_smarty_hook'] = $old_var['skip_smarty_hook'];
|
|
$serendipity['skip_smarty_hooks'] = $old_var['skip_smarty_hooks'];
|
|
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Shows a commentform
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* id: An entryid to show the commentform for
|
|
* url: an optional HTML target link for the form
|
|
* comments: Optional array of containing comments
|
|
* data: possible pre-submitted values to the input values
|
|
* showToolbar: Toggle whether to show extended options of the comment form
|
|
* moderate_comments: Toggle whether comments to this entry are allowed
|
|
* @param object Smarty object
|
|
* @return void
|
|
*/
|
|
function serendipity_smarty_showCommentForm($params, $smarty) {
|
|
global $serendipity;
|
|
|
|
if (!isset($params['id']) || !isset($params['entry'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'id' or 'entry' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
if (empty($params['url'])) {
|
|
$params['url'] = $serendipity['serendipityHTTPPath'] . $serendipity['indexFile'] . '?url=' . $params['entry']['commURL'];
|
|
}
|
|
|
|
if (!isset($params['comments'])) {
|
|
$params['comments'] = NULL;
|
|
}
|
|
|
|
if (!isset($params['data'])) {
|
|
$params['data'] = $serendipity['POST'];
|
|
}
|
|
|
|
if (!isset($params['showToolbar'])) {
|
|
$params['showToolbar'] = true;
|
|
}
|
|
|
|
if (!isset($params['moderate_comments'])) {
|
|
$params['moderate_comments'] = serendipity_db_bool($params['entry']['moderate_comments']);
|
|
}
|
|
|
|
$comment_add_data = array(
|
|
'comments_messagestack' => (isset($serendipity['messagestack']['comments']) ? (array)$serendipity['messagestack']['comments'] : array()),
|
|
'is_comment_added' => (isset($serendipity['GET']['csuccess']) && $serendipity['GET']['csuccess'] == 'true' ? true: false),
|
|
'is_comment_moderate' => (isset($serendipity['GET']['csuccess']) && $serendipity['GET']['csuccess'] == 'moderate' ? true: false)
|
|
);
|
|
|
|
$smarty->assign($comment_add_data);
|
|
|
|
serendipity_displayCommentForm(
|
|
$params['id'],
|
|
$params['url'],
|
|
$params['comments'],
|
|
$params['data'],
|
|
$params['showToolbar'],
|
|
$params['moderate_comments'],
|
|
$params['entry']
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Be able to include the output of a sidebar plugin within a smarty template
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* class: The classname of the plugin to show
|
|
* id: An ID of a plugin to show
|
|
* side: The side of a plugin to show (left|right|hidden)
|
|
* negate: Revert previous filters
|
|
* @param object Smarty object
|
|
* @return string The Smarty HTML response
|
|
*/
|
|
function serendipity_smarty_showPlugin($params, $smarty) {
|
|
global $serendipity;
|
|
|
|
if (!isset($params['class']) && !isset($params['id'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'class' or 'id' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
if (!isset($params['side'])) {
|
|
$params['side'] = '*';
|
|
}
|
|
|
|
if (!isset($params['negate'])) {
|
|
$params['negate'] = null;
|
|
}
|
|
if (empty($params['template'])) {
|
|
$params['template'] = 'sidebar.tpl';
|
|
}
|
|
|
|
$out = serendipity_plugin_api::generate_plugins($params['side'], $params['negate'], $params['class'], $params['id'], $params['template']);
|
|
|
|
if (empty($out) && !empty($params['empty'])) {
|
|
return $params['empty'];
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Get total count for specific objects
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* what: The type of count to show: "entries", "trackbacks", "comments"
|
|
* @param object Smarty object
|
|
* @return string The Smarty HTML response
|
|
*/
|
|
function serendipity_smarty_getTotalCount($params, $smarty) {
|
|
if (!isset($params['what'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'what' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
return serendipity_getTotalCount($params['what']);
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Be able to execute the hook of an event plugin and return its output
|
|
*
|
|
* Listens to specific serendipity global variables:
|
|
* $serendipity['skip_smarty_hooks'] - If TRUE, no plugins will be executed at all
|
|
* $serendipity['skip_smarty_hook'] - Can be set to an array of plugin hooks to NOT execute
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* hook: The name of the event hook
|
|
* hookAll: boolean whether unknown hooks shall be executed
|
|
* data: The $eventData to an event plugin
|
|
* addData: the $addData to an event plugin
|
|
* @param object Smarty object
|
|
* @return null
|
|
*/
|
|
function serendipity_smarty_hookPlugin($params, $smarty) {
|
|
global $serendipity;
|
|
static $hookable = array('frontend_header',
|
|
'entries_header',
|
|
'entries_footer',
|
|
'frontend_comment',
|
|
'frontend_footer');
|
|
if (!isset($params['hook'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'hook' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
if (!in_array($params['hook'], $hookable) && $params['hookAll'] != 'true') {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": illegal hook '". $params['hook'] ."' (" . $params['hookAll'] . ")", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
// Smarty hooks can be bypassed via an internal variable (temporarily)
|
|
if (isset($serendipity['skip_smarty_hooks']) && $serendipity['skip_smarty_hooks']) {
|
|
return;
|
|
}
|
|
|
|
// A specific hook can also be bypassed by creating an associative array like this:
|
|
// $serendipity['skip_smarty_hook'] = array('entries_header');
|
|
// That would only skip the entries_header event hook, but allow all others.
|
|
// Of course it cannot be used in conjunction with the all-blocking skip_smarty_hooks.
|
|
if (isset($serendipity['skip_smarty_hook']) && is_array($serendipity['skip_smarty_hook']) && isset($serendipity['skip_smarty_hook'][$params['hook']])) {
|
|
return;
|
|
}
|
|
|
|
if (!isset($params['data'])) {
|
|
if (isset($params['eventData'])) {
|
|
$params['data'] = &$params['eventData'];
|
|
} else {
|
|
$params['data'] = &$serendipity;
|
|
}
|
|
}
|
|
|
|
if (!isset($params['addData'])) {
|
|
$params['addData'] = null;
|
|
}
|
|
|
|
serendipity_plugin_api::hook_event($params['hook'], $params['data'], $params['addData']);
|
|
}
|
|
|
|
/**
|
|
* Smarty Modifier: Be able to execute the hook of an event plugin and return its output, uses a REFERENCED variable.
|
|
*
|
|
* Listens to specific serendipity global variables:
|
|
* $serendipity['skip_smarty_hooks'] - If TRUE, no plugins will be executed at all
|
|
* $serendipity['skip_smarty_hook'] - Can be set to an array of plugin hooks to NOT execute
|
|
*
|
|
* @access public
|
|
* @param mixed EventData (referenced)
|
|
* @param string Event hook name
|
|
* @param mixed Additional data
|
|
* @return null
|
|
*/
|
|
function serendipity_smarty_refhookPlugin($eventData, $hook, $addData = null) {
|
|
global $serendipity;
|
|
|
|
if (!isset($hook)) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'hook' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
// Smarty hooks can be bypassed via an internal variable (temporarily)
|
|
if (isset($serendipity['skip_smarty_hooks']) && $serendipity['skip_smarty_hooks']) {
|
|
return;
|
|
}
|
|
|
|
// A specific hook can also be bypassed by creating an associative array like this:
|
|
// $serendipity['skip_smarty_hook'] = array('entries_header');
|
|
// That would only skip the entries_header event hook, but allow all others.
|
|
// Of course it cannot be used in conjunction with the all-blocking skip_smarty_hooks.
|
|
if (isset($serendipity['skip_smarty_hook']) && is_array($serendipity['skip_smarty_hook']) && isset($serendipity['skip_smarty_hook'][$hook])) {
|
|
return;
|
|
}
|
|
|
|
serendipity_plugin_api::hook_event($hook, $eventData, $addData);
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Prints a list of sidebar plugins
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* side: The plugin side to show (left|right|hidden)
|
|
* @param object Smarty object
|
|
* @return string The HTML code of a plugin's output
|
|
*/
|
|
function serendipity_smarty_printSidebar($params, $smarty) {
|
|
if ( !isset($params['side']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'side' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
if (isset($params['template'])) {
|
|
return serendipity_plugin_api::generate_plugins($params['side'], false, null, null, $params['template']);
|
|
} else {
|
|
return serendipity_plugin_api::generate_plugins($params['side']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Get the full path to a template file
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* file: The filename you want to include (any file within your template directory or the 'default' template if not found)
|
|
* @param object Smarty object
|
|
* @return string The requested filename with full path
|
|
*/
|
|
function serendipity_smarty_getFile($params, $smarty) {
|
|
if ( !isset($params['file']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'file' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
return serendipity_getTemplateFile($params['file'], 'serendipityHTTPPath', $params['frontend'] ?? false);
|
|
}
|
|
|
|
function serendipity_smarty_getConfigVar($params, $smarty) {
|
|
if ( !isset($params['key']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'key' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
return serendipity_get_config_var($params['key']);
|
|
}
|
|
|
|
function serendipity_smarty_setFormToken($params, $smarty) {
|
|
if ( isset($params['type']) ) {
|
|
return serendipity_setFormToken($params['type']);
|
|
}
|
|
return serendipity_setFormToken();
|
|
}
|
|
|
|
|
|
/**
|
|
* Smarty Function: Picks a specified key from an array and returns it
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* array: The array you want to check
|
|
* key: The keyname
|
|
* default: What (string) to return when array does not contain the key.
|
|
* @param object Smarty object
|
|
* @return string The requested filename with full path
|
|
*/
|
|
function serendipity_smarty_pickKey($params, $smarty) {
|
|
if ( !isset($params['array']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'array' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
if ( !isset($params['key']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'key' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
return serendipity_pickKey($params['array'], $params['key'], $params['default']);
|
|
}
|
|
|
|
|
|
/**
|
|
* Smarty Function: Get a permalink for an entry
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* entry: $entry data to pull title etc. out of
|
|
* is_comments: Whether a permalink for a comment feed should be embedded
|
|
* @param object Smarty object
|
|
* @return string The permalink
|
|
*/
|
|
function serendipity_smarty_rss_getguid($params, $smarty) {
|
|
if ( !isset($params['entry']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'entry' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
if ( !isset($params['is_comments']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'is_comments' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
return serendipity_rss_getguid($params['entry'], $params['is_comments']);
|
|
}
|
|
|
|
/**
|
|
* Smarty Modifier: Format a timestamp
|
|
*
|
|
* @access public
|
|
* @param int The timestamp to format (unix seconds)
|
|
* @param string The strftime() format options on how to format this string
|
|
* @param boolean Shall timezone conversions be applied?
|
|
* @param boolean Try to detect a valid timestamp?
|
|
* @param boolean Use strftime or date?
|
|
* @return
|
|
*/
|
|
function serendipity_smarty_formatTime($timestamp, $format, $useOffset = true, $detectTimestamp = false, $useDate = false) {
|
|
if ($detectTimestamp !== false && stristr($detectTimestamp, 'date') === false) {
|
|
return $timestamp;
|
|
}
|
|
|
|
if (defined($format)) {
|
|
return serendipity_formatTime(constant($format), $timestamp, $useOffset, $useDate);
|
|
} else {
|
|
return serendipity_formatTime($format, $timestamp, $useOffset, $useDate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Show comments to an entry
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* entry: The $entry data
|
|
* mode: The default viewmode (threaded/linear)
|
|
* @param object Smarty object
|
|
* @return string The HTML code with the comments
|
|
*/
|
|
function &serendipity_smarty_printComments($params, $smarty) {
|
|
global $serendipity;
|
|
|
|
if (!isset($params['entry'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'entry' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
if (!isset($params['mode'])) {
|
|
$params['mode'] = VIEWMODE_THREADED;
|
|
}
|
|
|
|
if (isset($params['order']) && $params['order'] != 'DESC') {
|
|
$params['order'] = 'ASC';
|
|
}
|
|
|
|
$comments = serendipity_fetchComments($params['entry'], (int)($params['limit'] ?? null), 'co.id ' . ($params['order'] ?? null));
|
|
|
|
if (!empty($serendipity['POST']['preview'])) {
|
|
$comments[] =
|
|
array(
|
|
'email' => $serendipity['POST']['email'],
|
|
'author' => $serendipity['POST']['name'],
|
|
'body' => $serendipity['POST']['comment'],
|
|
'url' => $serendipity['POST']['url'],
|
|
'parent_id' => $serendipity['POST']['replyTo'],
|
|
'timestamp' => time()
|
|
);
|
|
}
|
|
|
|
if (empty($params['depth'])) {
|
|
$params['depth'] = 0;
|
|
}
|
|
|
|
if (empty($params['trace'])) {
|
|
$params['trace'] = null;
|
|
}
|
|
|
|
if (empty($params['block'])) {
|
|
$params['block'] = 'COMMENTS';
|
|
}
|
|
|
|
if (empty($params['template'])) {
|
|
$params['template'] = 'comments.tpl';
|
|
}
|
|
|
|
$out = serendipity_printComments($comments, $params['mode'], $params['depth'], $params['trace'], $params['block'], $params['template']);
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* Smarty Function: Show Trackbacks
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* entry: The $entry data for the trackbacks
|
|
* @param object Smarty object
|
|
* @return
|
|
*/
|
|
function &serendipity_smarty_printTrackbacks($params, $smarty) {
|
|
if ( !isset($params['entry']) ) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'entry' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
$trackbacks =& serendipity_fetchTrackbacks($params['entry']);
|
|
|
|
if (empty($params['depth'])) {
|
|
$params['depth'] = 0;
|
|
}
|
|
|
|
if (empty($params['trace'])) {
|
|
$params['trace'] = null;
|
|
}
|
|
|
|
if (empty($params['block'])) {
|
|
$params['block'] = 'TRACKBACKS';
|
|
}
|
|
|
|
if (empty($params['template'])) {
|
|
$params['template'] = 'trackbacks.tpl';
|
|
}
|
|
|
|
$out = serendipity_printComments($trackbacks, VIEWMODE_LINEAR, $params['depth'], $params['trace'], $params['block'], $params['template']);
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* Get the Serendipity dimensions for an image
|
|
*
|
|
* @access public
|
|
* @param array Smarty parameter input array:
|
|
* file: The image file to get image data for
|
|
* assign: The variable to assign the image data array to
|
|
* @param object Smarty object
|
|
* @return string Empty
|
|
*/
|
|
function serendipity_smarty_getImageSize($params, $smarty) {
|
|
global $serendipity;
|
|
|
|
if (!isset($params['file'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'file' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
if (!isset($params['assign'])) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .": missing 'assign' parameter", E_USER_WARNING);
|
|
return;
|
|
}
|
|
|
|
// Is it a correct filesystem absolute path?
|
|
$file = $params['file'];
|
|
// Most likely the user specified an HTTP path
|
|
if (!file_exists($file)) {
|
|
$file = $_SERVER['DOCUMENT_ROOT'] . $file;
|
|
}
|
|
// Maybe wants a template file (returns filesystem path)
|
|
if (!file_exists($file)) {
|
|
$file = serendipity_getTemplateFile($params['file']);
|
|
}
|
|
// If no file, trigger an error
|
|
if (!file_exists($file)) {
|
|
trigger_error("Smarty Error: " . __FUNCTION__ .': file ' . $params['file'] . NOT_FOUND . ' ', E_USER_WARNING);
|
|
return;
|
|
}
|
|
$smarty->assign($params['assign'], serendipity_getimagesize($file));
|
|
}
|
|
|
|
/**
|
|
* Smarty Prefilter: Replace constants to direkt $smarty.const. access
|
|
*
|
|
* @access public
|
|
* @param string Template source content
|
|
* @param object Smarty object
|
|
* @return
|
|
*/
|
|
function &serendipity_replaceSmartyVars($tpl_source, $smarty) {
|
|
$tpl_source = str_replace('$CONST.', '$smarty.const.', $tpl_source);
|
|
return $tpl_source;
|
|
}
|
|
|
|
/**
|
|
* Initialize the Smarty framework for use in Serendipity
|
|
*
|
|
* @access public
|
|
* @return null
|
|
*/
|
|
function serendipity_smarty_init($vars = array()) {
|
|
global $serendipity, $template_config, $template_global_config, $template_config_groups;
|
|
|
|
if (!isset($serendipity['smarty'])) {
|
|
|
|
$template_dir = $serendipity['serendipityPath'] . $serendipity['templatePath'] . ($serendipity['template'] ?? null);
|
|
|
|
if (!defined('IN_serendipity_admin') && file_exists($template_dir . '/template.inc.php')) {
|
|
// If this file exists, a custom template engine will be loaded.
|
|
// Beware: Smarty is used in the Admin backend, despite of this.
|
|
include_once $template_dir . '/template.inc.php';
|
|
} else {
|
|
|
|
// Backend template overwritten here (NOT earlier due to frontend specific check)
|
|
if (defined('IN_serendipity_admin')) {
|
|
$template_dir = $serendipity['serendipityPath'] . $serendipity['templatePath'] . $serendipity['template_backend'];
|
|
}
|
|
|
|
// Set a session variable if Smarty fails:
|
|
$prev_smarty = $_SESSION['no_smarty'] ?? null;
|
|
$_SESSION['no_smarty'] = true;
|
|
|
|
// define cache resources to load with smarty - see smarty cache readme - needs enabled cache!
|
|
#@define('APC_EXTENSION_LOADED', extension_loaded('apc') && ini_get('apc.enabled'));
|
|
#@define('MEMCACHE_EXTENSION_LOADED', (class_exists('Memcached',false) || class_exists('Memcache',false)) && (extension_loaded("memcached") || extension_loaded("memcache")));
|
|
|
|
if (!class_exists('Smarty')) {
|
|
return false;
|
|
}
|
|
|
|
// include the serendipity smarty constructor
|
|
if (!class_exists('Serendipity_Smarty')) {
|
|
include_once S9Y_INCLUDE_PATH . '/include/serendipity_smarty_class.inc.php';
|
|
}
|
|
|
|
if (!class_exists('Serendipity_Smarty')) {
|
|
return false;
|
|
}
|
|
|
|
// set smarty instance
|
|
#$serendipity['smarty'] = new Serendipity_Smarty;
|
|
// initialize smarty object by instance
|
|
$serendipity['smarty'] = Serendipity_Smarty::getInstance();
|
|
// debug moved to class
|
|
|
|
// Hooray for Smarty:
|
|
$_SESSION['no_smarty'] = $prev_smarty;
|
|
|
|
// enable security policy by instance of the Smarty_Security class
|
|
$serendipity['smarty']->enableSecurity('Serendipity_Smarty_Security_Policy');
|
|
|
|
// debugging...
|
|
#echo '<pre>';print_r($serendipity['smarty']);echo '</pre>';#exit;
|
|
#$serendipity['smarty']->testInstall();exit;
|
|
// extreme debugging with undocumented internal flag which enables a trace output from the parser during debugging
|
|
#$serendipity['smarty']->_parserdebug = true; // be careful!
|
|
|
|
/**
|
|
* ToDo: Check for possible API changes in Smarty 3.2 [smarty_modifier_foobar, --> [smarty_modifier_foobar, smarty_function_foobar, smarty_block_foobar] (in class)]
|
|
* smarty_modifier_foobar(Smarty $smarty, $string, ...) vs. smarty_modifier_foobar($string, ...)
|
|
**/
|
|
$serendipity['smarty']->registerPlugin('modifier', 'makeFilename', 'serendipity_makeFilename');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'xhtml_target', 'serendipity_xhtml_target');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'emptyPrefix', 'serendipity_emptyPrefix');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'formatTime', 'serendipity_smarty_formatTime');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'serendipity_utf8_encode', 'serendipity_utf8_encode');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'ifRemember', 'serendipity_ifRemember');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'checkPermission', 'serendipity_checkPermission');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'serendipity_refhookPlugin', 'serendipity_smarty_refhookPlugin');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'serendipity_html5time', 'serendipity_smarty_html5time');
|
|
$serendipity['smarty']->registerPlugin('modifier', 'rewriteURL', 'serendipity_rewriteURL');
|
|
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_printSidebar', 'serendipity_smarty_printSidebar');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_hookPlugin', 'serendipity_smarty_hookPlugin');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_showPlugin', 'serendipity_smarty_showPlugin');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_getFile', 'serendipity_smarty_getFile');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_printComments', 'serendipity_smarty_printComments');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_printTrackbacks', 'serendipity_smarty_printTrackbacks');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_rss_getguid', 'serendipity_smarty_rss_getguid');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_fetchPrintEntries', 'serendipity_smarty_fetchPrintEntries');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_getTotalCount', 'serendipity_smarty_getTotalCount');
|
|
$serendipity['smarty']->registerPlugin('function', 'pickKey', 'serendipity_smarty_pickKey');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_showCommentForm', 'serendipity_smarty_showCommentForm');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_getImageSize', 'serendipity_smarty_getImageSize');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_getConfigVar', 'serendipity_smarty_getConfigVar');
|
|
$serendipity['smarty']->registerPlugin('function', 'serendipity_setFormToken', 'serendipity_smarty_setFormToken');
|
|
|
|
$serendipity['smarty']->registerFilter('pre', 'serendipity_replaceSmartyVars');
|
|
|
|
}
|
|
|
|
if (!isset($serendipity['smarty_file'])) {
|
|
$serendipity['smarty_file'] = 'index.tpl';
|
|
}
|
|
|
|
$category = false;
|
|
$category_info = array();
|
|
if (isset($serendipity['GET']['category'])) {
|
|
$category = (int)$serendipity['GET']['category'];
|
|
if (isset($GLOBALS['cInfo'])) {
|
|
$category_info = $GLOBALS['cInfo'];
|
|
} else {
|
|
$category_info = serendipity_fetchCategoryInfo($category);
|
|
}
|
|
}
|
|
|
|
if (!isset($serendipity['smarty_vars']['head_link_stylesheet'])) {
|
|
$serendipity['smarty_vars']['head_link_stylesheet_frontend'] = serendipity_rewriteURL('serendipity.css');
|
|
|
|
if (defined('IN_serendipity_admin') && IN_serendipity_admin === true) {
|
|
$serendipity['smarty_vars']['head_link_stylesheet'] = serendipity_rewriteURL('serendipity_admin.css');
|
|
} else {
|
|
$serendipity['smarty_vars']['head_link_stylesheet'] = serendipity_rewriteURL('serendipity.css');
|
|
}
|
|
|
|
// When templates are switched, append a specific version string to make sure the browser does not cache the CSS
|
|
if (strstr($serendipity['smarty_vars']['head_link_stylesheet'], '?')) {
|
|
$serendipity['smarty_vars']['head_link_stylesheet'] .= '&v=' . ($serendipity['last_template_change'] ?? null);
|
|
$serendipity['smarty_vars']['head_link_stylesheet_frontend'] .= '&v=' . ($serendipity['last_template_change'] ?? null);
|
|
} else {
|
|
$serendipity['smarty_vars']['head_link_stylesheet'] .= '?v=' . $serendipity['last_template_change'];
|
|
$serendipity['smarty_vars']['head_link_stylesheet_frontend'] .= '?v=' . $serendipity['last_template_change'];
|
|
}
|
|
}
|
|
|
|
if (!isset($serendipity['smarty_vars']['head_link_script'])) {
|
|
if (defined('IN_serendipity_admin') && IN_serendipity_admin === true) {
|
|
$serendipity['smarty_vars']['head_link_script'] = serendipity_rewriteURL('serendipity_admin.js');
|
|
} else {
|
|
$serendipity['smarty_vars']['head_link_script'] = serendipity_rewriteURL('serendipity.js');
|
|
}
|
|
|
|
if (strstr($serendipity['smarty_vars']['head_link_script'], '?')) {
|
|
$serendipity['smarty_vars']['head_link_script'] .= '&v=' . ($serendipity['last_template_change'] ?? null);
|
|
} else {
|
|
$serendipity['smarty_vars']['head_link_script'] .= '?v=' . $serendipity['last_template_change'];
|
|
}
|
|
}
|
|
|
|
$wysiwyg_customPlugin = $wysiwyg_customConfig = null;
|
|
|
|
if (defined('IN_serendipity_admin') && array_key_exists('wysiwyg', $serendipity) && $serendipity['wysiwyg']) {
|
|
|
|
// backwards compatibility with removed force-settings
|
|
if (strpos($serendipity['wysiwygToolbar'], 'NOCC-') !== false) {
|
|
$serendipity['wysiwygToolbar'] = substr($serendipity['wysiwygToolbar'], 5);
|
|
}
|
|
// check ckeditor custom plugin file
|
|
$ccp = serendipity_getTemplateFile('admin/ckeditor_custom_plugin.js', 'serendipityHTTPPath', true);
|
|
$wysiwyg_customPlugin = (!empty($ccp)) ? $ccp : $serendipity['serendipityHTTPPath'] . 'htmlarea/ckeditor_s9y_plugin.js';
|
|
|
|
// check ckeditor custom config file
|
|
$ccc = serendipity_getTemplateFile('admin/ckeditor_custom_config.js', 'serendipityHTTPPath', true);
|
|
$wysiwyg_customConfig = (!empty($ccc)) ? $ccc : $serendipity['serendipityHTTPPath'] . 'htmlarea/ckeditor_s9y_config.js';
|
|
}
|
|
|
|
if (array_key_exists('enableBackendPopupGranular', $serendipity)) {
|
|
$_force_backendpopups = explode(',', $serendipity['enableBackendPopupGranular']);
|
|
} else {
|
|
$_force_backendpopups = [];
|
|
}
|
|
$force_backendpopups = array();
|
|
foreach($_force_backendpopups AS $fbp_key => $fbp_val) {
|
|
$fbp_val = trim($fbp_val);
|
|
if (empty($fbp_val)) continue;
|
|
$force_backendpopups[$fbp_val] = $fbp_val;
|
|
}
|
|
|
|
$serendipity['smarty']->assign(
|
|
array(
|
|
'head_charset' => 'UTF-8',
|
|
'head_version' => $serendipity['version'],
|
|
'head_title' => $serendipity['head_title'] ?? null,
|
|
'head_subtitle' => $serendipity['head_subtitle'] ?? null,
|
|
'head_link_stylesheet' => $serendipity['smarty_vars']['head_link_stylesheet'],
|
|
'head_link_script' => $serendipity['smarty_vars']['head_link_script'],
|
|
'head_link_stylesheet_frontend' => $serendipity['smarty_vars']['head_link_stylesheet_frontend'] ?? null,
|
|
|
|
'is_xhtml' => true,
|
|
'use_popups' => $serendipity['enablePopup'] ?? null,
|
|
'use_backendpopups' => $serendipity['enableBackendPopup'] ?? null,
|
|
'force_backendpopups' => $force_backendpopups,
|
|
'is_embedded' => $serendipity['embed'] ?? false,
|
|
'is_raw_mode' => $serendipity['smarty_raw_mode'] ?? null,
|
|
'is_logged_in' => serendipity_userLoggedIn(),
|
|
|
|
'entry_id' => (isset($serendipity['GET']['id']) && is_numeric($serendipity['GET']['id'])) ? $serendipity['GET']['id'] : false,
|
|
'is_single_entry' => (isset($serendipity['GET']['id']) && is_numeric($serendipity['GET']['id'])),
|
|
|
|
'blogTitle' => $serendipity['blogTitle'] ?? null,
|
|
'blogSubTitle' => (!empty($serendipity['blogSubTitle']) ? $serendipity['blogSubTitle'] : ''),
|
|
'blogDescription' => $serendipity['blogDescription'] ?? null,
|
|
|
|
'serendipityHTTPPath' => $serendipity['serendipityHTTPPath'] ?? null,
|
|
'serendipityDefaultBaseURL' => $serendipity['defaultBaseURL'] ?? null,
|
|
'serendipityBaseURL' => $serendipity['baseURL'] ?? null,
|
|
'serendipityRewritePrefix' => $serendipity['rewrite'] == 'none' ? $serendipity['indexFile'] . '?/' : '',
|
|
'serendipityIndexFile' => $serendipity['indexFile'],
|
|
'serendipityVersion' => ($serendipity['expose_s9y'] ? $serendipity['version'] : ''),
|
|
|
|
'lang' => $serendipity['lang'],
|
|
'category' => $category,
|
|
'category_info' => $category_info,
|
|
'template' => $serendipity['template'],
|
|
'template_backend' => $serendipity['template_backend'] ?? null,
|
|
'wysiwygToolbar' => $serendipity['wysiwygToolbar'] ?? null,
|
|
'wysiwyg_customPlugin' => $wysiwyg_customPlugin,
|
|
'wysiwyg_customConfig' => $wysiwyg_customConfig,
|
|
'use_autosave' => (serendipity_db_bool($serendipity['use_autosave'] ?? false) ? 'true' : 'false'),
|
|
|
|
'dateRange' => (!empty($serendipity['range']) ? $serendipity['range'] : array())
|
|
)
|
|
);
|
|
|
|
if (count($vars) > 0) {
|
|
$serendipity['smarty']->assign($vars);
|
|
}
|
|
|
|
// For advanced usage, we allow template authors to create a file 'config.inc.php' where they can
|
|
// setup custom smarty variables, modifiers etc. to use in their templates.
|
|
|
|
// If a template engine is defined we need that config.inc.php file as well. The template's actual file is loaded after that to be able to overwrite config.
|
|
if (isset($serendipity['template_engine']) && $serendipity['template_engine'] != null) {
|
|
$p = explode(',', $serendipity['template_engine']);
|
|
foreach($p AS $te) {
|
|
$config = $serendipity['serendipityPath'] . $serendipity['templatePath'] . trim($te) . '/config.inc.php';
|
|
|
|
if (file_exists($config)) {
|
|
include_once $config;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// FIRST: Load config of the currently configured FRONTEND template. We might actually need this in the backend (sidebar configuration, IPTC options, some others).
|
|
// SECOND: Load config of the currently set template, which can also be the BACKEND template, or be the same as before. include_once takes care of only including the file once.
|
|
$config = $serendipity['serendipityPath'] . $serendipity['templatePath'] . $serendipity['template'] . '/config.inc.php';
|
|
if (file_exists($config)) {
|
|
include_once $config;
|
|
}
|
|
|
|
$config = $serendipity['smarty']->getConfigDir(0) . '/config.inc.php';
|
|
if (file_exists($config)) {
|
|
include_once $config;
|
|
}
|
|
|
|
|
|
if (is_array($template_loaded_config ?? null)) {
|
|
$template_vars =& $template_loaded_config;
|
|
$serendipity['smarty']->assignByRef('template_option', $template_vars);
|
|
} elseif (is_array($template_config)) {
|
|
$template_vars =& serendipity_loadThemeOptions($template_config, $serendipity['smarty_vars']['template_option']);
|
|
$serendipity['smarty']->assignByRef('template_option', $template_vars);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Purge compiled Smarty Templates
|
|
*
|
|
* @access public
|
|
* @return null
|
|
*/
|
|
function serendipity_smarty_purge() {
|
|
global $serendipity;
|
|
|
|
serendipity_smarty_init(); # need initiated smarty to get the compile/cache dir
|
|
$dir = new RecursiveDirectoryIterator($serendipity['smarty']->getCompileDir());
|
|
$ite = new RecursiveIteratorIterator($dir, RecursiveIteratorIterator::LEAVES_ONLY, RecursiveIteratorIterator::CATCH_GET_CHILD);
|
|
$files = new RegexIterator($ite, '@.*\.tpl\.php$@', RegexIterator::GET_MATCH);
|
|
foreach($files as $file) {
|
|
if (is_writable($file[0])) {
|
|
unlink($file[0]);
|
|
} else {
|
|
if (is_object($serendipity['logger'])) $serendipity['logger']->warning("Could not delete " . $file[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shut down the Smarty Framework, output all parsed data
|
|
*
|
|
* This function is meant to be used in embedded installations, like in Gallery.
|
|
* Function can be called from foreign applications. ob_start() needs to
|
|
* have been called before, and will be parsed into Smarty here
|
|
*
|
|
* @access public
|
|
* @param string The path to Serendipity
|
|
* @return null
|
|
*/
|
|
function serendipity_smarty_shutdown($serendipity_directory = '') {
|
|
global $serendipity;
|
|
|
|
#$cwd = getcwd();
|
|
chdir($serendipity_directory);
|
|
$raw_data = ob_get_contents();
|
|
ob_end_clean();
|
|
$serendipity['smarty']->assignByRef('content_message', $raw_data);
|
|
|
|
serendipity_smarty_fetch('CONTENT', 'content.tpl');
|
|
$serendipity['smarty']->assign('ENTRIES', '');
|
|
if (empty($serendipity['smarty_file'])) {
|
|
$serendipity['smarty_file'] = '404.tpl';
|
|
}
|
|
$serendipity['smarty']->display(serendipity_getTemplateFile($serendipity['smarty_file'], 'serendipityPath'));
|
|
}
|
|
|
|
/**
|
|
* Render a smarty-template
|
|
* $template: path to the template-file
|
|
* $data: map with the variables to assign
|
|
* $debugtype: If set, debug string is prepended. Can be set to HTML or JS.
|
|
* $debug: Possible debug string that is prepended to output
|
|
*/
|
|
function serendipity_smarty_show($template, $data = null, $debugtype = null, $debug = null) {
|
|
global $serendipity;
|
|
|
|
if (!is_object($serendipity['smarty'] ?? null)) {
|
|
serendipity_smarty_init();
|
|
}
|
|
|
|
$serendipity['smarty']->assign($data);
|
|
|
|
$tplfile = serendipity_getTemplateFile($template, 'serendipityPath', ($template == 'preview_iframe.tpl')); # for the preview_iframe.tpl, we want to ignore the backend theme
|
|
if ($debug !== null) {
|
|
if ($debugtype == "HTML") {
|
|
$debug = "<!-- Dynamically fetched " . serendipity_specialchars(str_replace($serendipity['serendipityPath'], '', $tplfile)) . " on " . date('Y-m-d H:i') . ", called from: " . $debug . " -->\n";
|
|
} else {
|
|
$debug = "/* Dynamically fetched " . serendipity_specialchars(str_replace($serendipity['serendipityPath'], '', $tplfile)) . " on " . date('Y-m-d H:i') . ", called from: " . $debug . " */\n";
|
|
}
|
|
}
|
|
|
|
return $debug . $serendipity['smarty']->fetch('file:'. $tplfile);
|
|
}
|